b2evolution

Multilingual multiuser multiblog engine

Home About Demo Download Hosting Extend Docs Support
b2evolution Technical Documentation (CVS HEAD) [ class tree: main ] [ index: main ] [ all elements ]

Source for file _idna_convert.class.php

Documentation is available at _idna_convert.class.php

  1. <?php
  2. // {{{ license
  3.  
  4. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4 foldmethod=marker: */
  5. //
  6. // +----------------------------------------------------------------------+
  7. // | This library is free software; you can redistribute it and/or modify |
  8. // | it under the terms of the GNU Lesser General Public License as       |
  9. // | published by the Free Software Foundation; either version 2.1 of the |
  10. // | License, or (at your option) any later version.                      |
  11. // |                                                                      |
  12. // | This library is distributed in the hope that it will be useful, but  |
  13. // | WITHOUT ANY WARRANTY; without even the implied warranty of           |
  14. // | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    |
  15. // | Lesser General Public License for more details.                      |
  16. // |                                                                      |
  17. // | You should have received a copy of the GNU Lesser General Public     |
  18. // | License along with this library; if not, write to the Free Software  |
  19. // | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 |
  20. // | USA.                                                                 |
  21. // +----------------------------------------------------------------------+
  22. //
  23.  
  24. // }}}
  25.  
  26. /**
  27.  * Encode/decode Internationalized Domain Names.
  28.  *
  29.  * The class allows to convert internationalized domain names
  30.  * (see RFC 3490 for details) as they can be used with various registries worldwide
  31.  * to be translated between their original (localized) form and their encoded form
  32.  * as it will be used in the DNS (Domain Name System).
  33.  *
  34.  * The class provides two public methods, encode() and decode(), which do exactly
  35.  * what you would expect them to do. You are allowed to use complete domain names,
  36.  * simple strings and complete email addresses as well. That means, that you might
  37.  * use any of the following notations:
  38.  *
  39.  * - www.nörgler.com
  40.  * - xn--nrgler-wxa
  41.  * - xn--brse-5qa.xn--knrz-1ra.info
  42.  *
  43.  * Unicode input might be given as either UTF-8 string, UCS-4 string or UCS-4
  44.  * array. Unicode output is available in the same formats.
  45.  * You can select your preferred format via {@link set_paramter()}.
  46.  *
  47.  * ACE input and output is always expected to be ASCII.
  48.  *
  49.  * @author  Matthias Sommerfeld <mso@phlylabs.de>
  50.  * @author  Leonid Kogan <lko@neuse.de>
  51.  * @copyright 2004-2009 phlyLabs Berlin, http://phlylabs.de
  52.  * @version 0.6.2
  53.  * @changelog since 0.5.1 class updated to PHP5/6 style should be compatible to PHP 4.3+
  54.  */
  55. class idna_convert
  56. {
  57.     // NP See below
  58.  
  59.     // Internal settings, do not mess with them
  60.     private $_punycode_prefix = 'xn--';
  61.     private $_invalid_ucs = 0x80000000;
  62.     private $_max_ucs = 0x10FFFF;
  63.     private $_base = 36;
  64.     private $_tmin = 1;
  65.     private $_tmax = 26;
  66.     private $_skew = 38;
  67.     private $_damp = 700;
  68.     private $_initial_bias = 72;
  69.     private $_initial_n = 0x80;
  70.     private $_sbase = 0xAC00;
  71.     private $_lbase = 0x1100;
  72.     private $_vbase = 0x1161;
  73.     private $_tbase = 0x11A7;
  74.     private $_lcount = 19;
  75.     private $_vcount = 21;
  76.     private $_tcount = 28;
  77.     private $_ncount = 588;   // _vcount * _tcount
  78.     private $_scount = 11172; // _lcount * _tcount * _vcount
  79.     private $_error = false;
  80.  
  81.     // See {@link set_paramter()} for details of how to change the following
  82.     // settings from within your script / application
  83.     private $_api_encoding = 'utf8';  // Default input charset is UTF-8
  84.     private $_allow_overlong = false; // Overlong UTF-8 encodings are forbidden
  85.     private $_strict_mode = false;    // Behave strict or not
  86.  
  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.         return true;
  101.     }
  102.  
  103.     /**
  104.      * Sets a new option value. Available options and values:
  105.      * [encoding - Use either UTF-8, UCS4 as array or UCS4 as string as input ('utf8' for UTF-8,
  106.      *         'ucs4_string' and 'ucs4_array' respectively for UCS4); The output is always UTF-8]
  107.      * [overlong - Unicode does not allow unnecessarily long encodings of chars,
  108.      *             to allow this, set this parameter to true, else to false;
  109.      *             default is false.]
  110.      * [strict - true: strict mode, good for registration purposes - Causes errors
  111.      *           on failures; false: loose mode, ideal for "wildlife" applications
  112.      *           by silently ignoring errors and returning the original input instead
  113.      *
  114.      * @param    mixed     Parameter to set (string: single parameter; array of Parameter => Value pairs)
  115.      * @param    string    Value to use (if parameter 1 is a string)
  116.      * @return   boolean   true on success, false otherwise
  117.      */
  118.     public function set_parameter($option, $value = false)
  119.     {
  120.         if (!is_array($option)) {
  121.             $option = array($option => $value);
  122.         }
  123.         foreach ($option as $k => $v) {
  124.             switch ($k) {
  125.             case 'encoding':
  126.                 switch ($v) {
  127.                 case 'utf8':
  128.                 case 'ucs4_string':
  129.                 case 'ucs4_array':
  130.                     $this->_api_encoding = $v;
  131.                     break;
  132.                 default:
  133.                     $this->_error('Set Parameter: Unknown parameter '.$v.' for option '.$k);
  134.                     return false;
  135.                 }
  136.                 break;
  137.             case 'overlong':
  138.                 $this->_allow_overlong = ($v) ? true : false;
  139.                 break;
  140.             case 'strict':
  141.                 $this->_strict_mode = ($v) ? true : false;
  142.                 break;
  143.             default:
  144.                 $this->_error('Set Parameter: Unknown option '.$k);
  145.                 return false;
  146.             }
  147.         }
  148.         return true;
  149.     }
  150.  
  151.     /**
  152.      * Decode a given ACE domain name
  153.      * @param    string   Domain name (ACE string)
  154.      *  [@param    string   Desired output encoding, see {@link set_parameter}]
  155.      * @return   string   Decoded Domain name (UTF-8 or UCS-4)
  156.      */
  157.     public function decode($input, $one_time_encoding = false)
  158.     {
  159.         // Optionally set
  160.         if ($one_time_encoding) {
  161.             switch ($one_time_encoding) {
  162.             case 'utf8':
  163.             case 'ucs4_string':
  164.             case 'ucs4_array':
  165.                 break;
  166.             default:
  167.                 $this->_error('Unknown encoding '.$one_time_encoding);
  168.                 return false;
  169.             }
  170.         }
  171.         // Make sure to drop any newline characters around
  172.         $input = trim($input);
  173.  
  174.         // Negotiate input and try to determine, whether it is a plain string,
  175.         // an email address or something like a complete URL
  176.         if (strpos($input, '@')) { // Maybe it is an email address
  177.             // No no in strict mode
  178.             if ($this->_strict_mode) {
  179.                 $this->_error('Only simple domain name parts can be handled in strict mode');
  180.                 return false;
  181.             }
  182.             list ($email_pref, $input) = explode('@', $input, 2);
  183.             $arr = explode('.', $input);
  184.             foreach ($arr as $k => $v) {
  185.                 if (preg_match('!^'.preg_quote($this->_punycode_prefix, '!').'!', $v)) {
  186.                     $conv = $this->_decode($v);
  187.                     if ($conv) $arr[$k] = $conv;
  188.                 }
  189.             }
  190.             $input = join('.', $arr);
  191.             $arr = explode('.', $email_pref);
  192.             foreach ($arr as $k => $v) {
  193.                 if (preg_match('!^'.preg_quote($this->_punycode_prefix, '!').'!', $v)) {
  194.                     $conv = $this->_decode($v);
  195.                     if ($conv) $arr[$k] = $conv;
  196.                 }
  197.             }
  198.             $email_pref = join('.', $arr);
  199.             $return = $email_pref . '@' . $input;
  200.         } elseif (preg_match('![:\./]!', $input)) { // Or a complete domain name (with or without paths / parameters)
  201.             // No no in strict mode
  202.             if ($this->_strict_mode) {
  203.                 $this->_error('Only simple domain name parts can be handled in strict mode');
  204.                 return false;
  205.             }
  206.             $parsed = parse_url($input);
  207.             if (isset($parsed['host'])) {
  208.                 $arr = explode('.', $parsed['host']);
  209.                 foreach ($arr as $k => $v) {
  210.                     $conv = $this->_decode($v);
  211.                     if ($conv) $arr[$k] = $conv;
  212.                 }
  213.                 $parsed['host'] = join('.', $arr);
  214.                 $return =
  215.                         (empty($parsed['scheme']) ? '' : $parsed['scheme'].(strtolower($parsed['scheme']) == 'mailto' ? ':' : '://'))
  216.                         .(empty($parsed['user']) ? '' : $parsed['user'].(empty($parsed['pass']) ? '' : ':'.$parsed['pass']).'@')
  217.                         .$parsed['host']
  218.                         .(empty($parsed['port']) ? '' : ':'.$parsed['port'])
  219.                         .(empty($parsed['path']) ? '' : $parsed['path'])
  220.                         .(empty($parsed['query']) ? '' : '?'.$parsed['query'])
  221.                         .(empty($parsed['fragment']) ? '' : '#'.$parsed['fragment']);
  222.             } else { // parse_url seems to have failed, try without it
  223.                 $arr = explode('.', $input);
  224.                 foreach ($arr as $k => $v) {
  225.                     $conv = $this->_decode($v);
  226.                     $arr[$k] = ($conv) ? $conv : $v;
  227.                 }
  228.                 $return = join('.', $arr);
  229.             }
  230.         } else { // Otherwise we consider it being a pure domain name string
  231.             $return = $this->_decode($input);
  232.             if (!$return) $return = $input;
  233.         }
  234.         // The output is UTF-8 by default, other output formats need conversion here
  235.         // If one time encoding is given, use this, else the objects property
  236.         switch (($one_time_encoding) ? $one_time_encoding : $this->_api_encoding) {
  237.         case 'utf8':
  238.             return $return;
  239.             break;
  240.         case 'ucs4_string':
  241.            return $this->_ucs4_to_ucs4_string($this->_utf8_to_ucs4($return));
  242.            break;
  243.         case 'ucs4_array':
  244.             return $this->_utf8_to_ucs4($return);
  245.             break;
  246.         default:
  247.             $this->_error('Unsupported output format');
  248.             return false;
  249.         }
  250.     }
  251.  
  252.     /**
  253.      * Encode a given UTF-8 domain name
  254.      * @param    string   Domain name (UTF-8 or UCS-4)
  255.      *  [@param    string   Desired input encoding, see {@link set_parameter}]
  256.      * @return   string   Encoded Domain name (ACE string)
  257.      */
  258.     public function encode($decoded, $one_time_encoding = false)
  259.     {
  260.         // Forcing conversion of input to UCS4 array
  261.         // If one time encoding is given, use this, else the objects property
  262.         switch ($one_time_encoding ? $one_time_encoding : $this->_api_encoding) {
  263.         case 'utf8':
  264.             $decoded = $this->_utf8_to_ucs4($decoded);
  265.             break;
  266.         case 'ucs4_string':
  267.            $decoded = $this->_ucs4_string_to_ucs4($decoded);
  268.         case 'ucs4_array':
  269.            break;
  270.         default:
  271.             $this->_error('Unsupported input format: '.($one_time_encoding ? $one_time_encoding : $this->_api_encoding));
  272.             return false;
  273.         }
  274.  
  275.         // No input, no output, what else did you expect?
  276.         if (empty($decoded)) return '';
  277.  
  278.         // Anchors for iteration
  279.         $last_begin = 0;
  280.         // Output string
  281.         $output = '';
  282.         foreach ($decoded as $k => $v) {
  283.             // Make sure to use just the plain dot
  284.             switch($v) {
  285.             case 0x3002:
  286.             case 0xFF0E:
  287.             case 0xFF61:
  288.                 $decoded[$k] = 0x2E;
  289.                 // Right, no break here, the above are converted to dots anyway
  290.             // Stumbling across an anchoring character
  291.             case 0x2E:
  292.             case 0x2F:
  293.             case 0x3A:
  294.             case 0x3F:
  295.             case 0x40:
  296.                 // Neither email addresses nor URLs allowed in strict mode
  297.                 if ($this->_strict_mode) {
  298.                    $this->_error('Neither email addresses nor URLs are allowed in strict mode.');
  299.                    return false;
  300.                 } else {
  301.                     // Skip first char
  302.                     if ($k) {
  303.                         $encoded = '';
  304.                         $encoded = $this->_encode(array_slice($decoded, $last_begin, (($k)-$last_begin)));
  305.                         if ($encoded) {
  306.                             $output .= $encoded;
  307.                         } else {
  308.                             $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($k)-$last_begin)));
  309.                         }
  310.                         $output .= chr($decoded[$k]);
  311.                     }
  312.                     $last_begin = $k + 1;
  313.                 }
  314.             }
  315.         }
  316.         // Catch the rest of the string
  317.         if ($last_begin) {
  318.             $inp_len = sizeof($decoded);
  319.             $encoded = '';
  320.             $encoded = $this->_encode(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
  321.             if ($encoded) {
  322.                 $output .= $encoded;
  323.             } else {
  324.                 $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
  325.             }
  326.             return $output;
  327.         } else {
  328.             if ($output = $this->_encode($decoded)) {
  329.                 return $output;
  330.             } else {
  331.                 return $this->_ucs4_to_utf8($decoded);
  332.             }
  333.         }
  334.     }
  335.  
  336.     /**
  337.      * Use this method to get the last error ocurred
  338.      * @param    void 
  339.      * @return   string   The last error, that occured
  340.      */
  341.     public function get_last_error()
  342.     {
  343.         return $this->_error;
  344.     }
  345.  
  346.     /**
  347.      * The actual decoding algorithm
  348.      * @param string 
  349.      * @return mixed 
  350.      */
  351.     private function _decode($encoded)
  352.     {
  353.         $decoded = array();
  354.         // find the Punycode prefix
  355.         if (!preg_match('!^'.preg_quote($this->_punycode_prefix, '!').'!', $encoded)) {
  356.             $this->_error('This is not a punycode string');
  357.             return false;
  358.         }
  359.         $encode_test = preg_replace('!^'.preg_quote($this->_punycode_prefix, '!').'!', '', $encoded);
  360.         // If nothing left after removing the prefix, it is hopeless
  361.         if (!$encode_test) {
  362.             $this->_error('The given encoded string was empty');
  363.             return false;
  364.         }
  365.         // Find last occurence of the delimiter
  366.         $delim_pos = strrpos($encoded, '-');
  367.         if ($delim_pos > strlen($this->_punycode_prefix)) {
  368.             for ($k = strlen($this->_punycode_prefix); $k < $delim_pos; ++$k) {
  369.                 $decoded[] = ord($encoded{$k});
  370.             }
  371.         }
  372.         $deco_len = count($decoded);
  373.         $enco_len = strlen($encoded);
  374.  
  375.         // Wandering through the strings; init
  376.         $is_first = true;
  377.         $bias = $this->_initial_bias;
  378.         $idx = 0;
  379.         $char = $this->_initial_n;
  380.  
  381.         for ($enco_idx = ($delim_pos) ? ($delim_pos + 1) : 0; $enco_idx < $enco_len; ++$deco_len) {
  382.             for ($old_idx = $idx, $w = 1, $k = $this->_base; 1 ; $k += $this->_base) {
  383.                 $digit = $this->_decode_digit($encoded{$enco_idx++});
  384.                 $idx += $digit * $w;
  385.                 $t = ($k <= $bias) ? $this->_tmin :
  386.                         (($k >= $bias + $this->_tmax) ? $this->_tmax : ($k - $bias));
  387.                 if ($digit < $t) break;
  388.                 $w = (int) ($w * ($this->_base - $t));
  389.             }
  390.             $bias = $this->_adapt($idx - $old_idx, $deco_len + 1, $is_first);
  391.             $is_first = false;
  392.             $char += (int) ($idx / ($deco_len + 1));
  393.             $idx %= ($deco_len + 1);
  394.             if ($deco_len > 0) {
  395.                 // Make room for the decoded char
  396.                 for ($i = $deco_len; $i > $idx; $i--) $decoded[$i] = $decoded[($i - 1)];
  397.             }
  398.             $decoded[$idx++] = $char;
  399.         }
  400.         return $this->_ucs4_to_utf8($decoded);
  401.     }
  402.  
  403.     /**
  404.      * The actual encoding algorithm
  405.      * @param  string 
  406.      * @return mixed 
  407.      */
  408.     private function _encode($decoded)
  409.     {
  410.         // We cannot encode a domain name containing the Punycode prefix
  411.         $extract = strlen($this->_punycode_prefix);
  412.         $check_pref = $this->_utf8_to_ucs4($this->_punycode_prefix);
  413.         $check_deco = array_slice($decoded, 0, $extract);
  414.  
  415.         if ($check_pref == $check_deco) {
  416.             $this->_error('This is already a punycode string');
  417.             return false;
  418.         }
  419.         // We will not try to encode strings consisting of basic code points only
  420.         $encodable = false;
  421.         foreach ($decoded as $k => $v) {
  422.             if ($v > 0x7a) {
  423.                 $encodable = true;
  424.                 break;
  425.             }
  426.         }
  427.         if (!$encodable) {
  428.             $this->_error('The given string does not contain encodable chars');
  429.             return false;
  430.         }
  431.         // Do NAMEPREP
  432.         $decoded = $this->_nameprep($decoded);
  433.         if (!$decoded || !is_array($decoded)) return false; // NAMEPREP failed
  434.         $deco_len  = count($decoded);
  435.         if (!$deco_len) return false; // Empty array
  436.         $codecount = 0; // How many chars have been consumed
  437.         $encoded = '';
  438.         // Copy all basic code points to output
  439.         for ($i = 0; $i < $deco_len; ++$i) {
  440.             $test = $decoded[$i];
  441.             // Will match [-0-9a-zA-Z]
  442.             if ((0x2F < $test && $test < 0x40) || (0x40 < $test && $test < 0x5B)
  443.                     || (0x60 < $test && $test <= 0x7B) || (0x2D == $test)) {
  444.                 $encoded .= chr($decoded[$i]);
  445.                 $codecount++;
  446.             }
  447.         }
  448.         if ($codecount == $deco_len) return $encoded; // All codepoints were basic ones
  449.  
  450.         // Start with the prefix; copy it to output
  451.         $encoded = $this->_punycode_prefix.$encoded;
  452.         // If we have basic code points in output, add an hyphen to the end
  453.         if ($codecount) $encoded .= '-';
  454.         // Now find and encode all non-basic code points
  455.         $is_first = true;
  456.         $cur_code = $this->_initial_n;
  457.         $bias = $this->_initial_bias;
  458.         $delta = 0;
  459.         while ($codecount < $deco_len) {
  460.             // Find the smallest code point >= the current code point and
  461.             // remember the last ouccrence of it in the input
  462.             for ($i = 0, $next_code = $this->_max_ucs; $i < $deco_len; $i++) {
  463.                 if ($decoded[$i] >= $cur_code && $decoded[$i] <= $next_code) {
  464.                     $next_code = $decoded[$i];
  465.                 }
  466.             }
  467.             $delta += ($next_code - $cur_code) * ($codecount + 1);
  468.             $cur_code = $next_code;
  469.  
  470.             // Scan input again and encode all characters whose code point is $cur_code
  471.             for ($i = 0; $i < $deco_len; $i++) {
  472.                 if ($decoded[$i] < $cur_code) {
  473.                     $delta++;
  474.                 } elseif ($decoded[$i] == $cur_code) {
  475.                     for ($q = $delta, $k = $this->_base; 1; $k += $this->_base) {
  476.                         $t = ($k <= $bias) ? $this->_tmin :
  477.                                 (($k >= $bias + $this->_tmax) ? $this->_tmax : $k - $bias);
  478.                         if ($q < $t) break;
  479.                         $encoded .= $this->_encode_digit(intval($t + (($q - $t) % ($this->_base - $t)))); //v0.4.5 Changed from ceil() to intval()
  480.                         $q = (int) (($q - $t) / ($this->_base - $t));
  481.                     }
  482.                     $encoded .= $this->_encode_digit($q);
  483.                     $bias = $this->_adapt($delta, $codecount+1, $is_first);
  484.                     $codecount++;
  485.                     $delta = 0;
  486.                     $is_first = false;
  487.                 }
  488.             }
  489.             $delta++;
  490.             $cur_code++;
  491.         }
  492.         return $encoded;
  493.     }
  494.  
  495.     /**
  496.      * Adapt the bias according to the current code point and position
  497.      * @param int $delta 
  498.      * @param int $npoints 
  499.      * @param int $is_first 
  500.      * @return int 
  501.      */
  502.     private function _adapt($delta, $npoints, $is_first)
  503.     {
  504.         $delta = intval($is_first ? ($delta / $this->_damp) : ($delta / 2));
  505.         $delta += intval($delta / $npoints);
  506.         for ($k = 0; $delta > (($this->_base - $this->_tmin) * $this->_tmax) / 2; $k += $this->_base) {
  507.             $delta = intval($delta / ($this->_base - $this->_tmin));
  508.         }
  509.         return intval($k + ($this->_base - $this->_tmin + 1) * $delta / ($delta + $this->_skew));
  510.     }
  511.  
  512.     /**
  513.      * Encoding a certain digit
  514.      * @param    int $d 
  515.      * @return string 
  516.      */
  517.     private function _encode_digit($d)
  518.     {
  519.         return chr($d + 22 + 75 * ($d < 26));
  520.     }
  521.  
  522.     /**
  523.      * Decode a certain digit
  524.      * @param    int $cp 
  525.      * @return int 
  526.      */
  527.     private function _decode_digit($cp)
  528.     {
  529.         $cp = ord($cp);
  530.         return ($cp - 48 < 10) ? $cp - 22 : (($cp - 65 < 26) ? $cp - 65 : (($cp - 97 < 26) ? $cp - 97 : $this->_base));
  531.     }
  532.  
  533.     /**
  534.      * Internal error handling method
  535.      * @param  string $error 
  536.      */
  537.     private function _error($error = '')
  538.     {
  539.         $this->_error = $error;
  540.     }
  541.  
  542.     /**
  543.      * Do Nameprep according to RFC3491 and RFC3454
  544.      * @param    array    Unicode Characters
  545.      * @return   string   Unicode Characters, Nameprep'd
  546.      */
  547.     private function _nameprep($input)
  548.     {
  549.         $output = array();
  550.         $error = false;
  551.         //
  552.         // Mapping
  553.         // Walking through the input array, performing the required steps on each of
  554.         // the input chars and putting the result into the output array
  555.         // While mapping required chars we apply the cannonical ordering
  556.         foreach ($input as $v) {
  557.             // Map to nothing == skip that code point
  558.             if (in_array($v, $this->NP['map_nothing'])) continue;
  559.             // Try to find prohibited input
  560.             if (in_array($v, $this->NP['prohibit']) || in_array($v, $this->NP['general_prohibited'])) {
  561.                 $this->_error('NAMEPREP: Prohibited input U+'.sprintf('%08X', $v));
  562.                 return false;
  563.             }
  564.             foreach ($this->NP['prohibit_ranges'] as $range) {
  565.                 if ($range[0] <= $v && $v <= $range[1]) {
  566.                     $this->_error('NAMEPREP: Prohibited input U+'.sprintf('%08X', $v));
  567.                     return false;
  568.                 }
  569.             }
  570.             // Hangul syllable decomposition
  571.             if (0xAC00 <= $v && $v <= 0xD7AF) {
  572.                 foreach ($this->_hangul_decompose($v) as $out) $output[] = (int) $out;
  573.             // There's a decomposition mapping for that code point
  574.             } elseif (isset($this->NP['replacemaps'][$v])) {
  575.                 foreach ($this->_apply_cannonical_ordering($this->NP['replacemaps'][$v]) as $out) {
  576.                     $output[] = (int) $out;
  577.                 }
  578.             } else {
  579.                 $output[] = (int) $v;
  580.             }
  581.         }
  582.         // Before applying any Combining, try to rearrange any Hangul syllables
  583.         $output = $this->_hangul_compose($output);
  584.         //
  585.         // Combine code points
  586.         //
  587.         $last_class = 0;
  588.         $last_starter = 0;
  589.         $out_len = count($output);
  590.         for ($i = 0; $i < $out_len; ++$i) {
  591.             $class = $this->_get_combining_class($output[$i]);
  592.             if ((!$last_class || $last_class > $class) && $class) {
  593.                 // Try to match
  594.                 $seq_len = $i - $last_starter;
  595.                 $out = $this->_combine(array_slice($output, $last_starter, $seq_len));
  596.                 // On match: Replace the last starter with the composed character and remove
  597.                 // the now redundant non-starter(s)
  598.                 if ($out) {
  599.                     $output[$last_starter] = $out;
  600.                     if (count($out) != $seq_len) {
  601.                         for ($j = $i+1; $j < $out_len; ++$j) $output[$j-1] = $output[$j];
  602.                         unset($output[$out_len]);
  603.                     }
  604.                     // Rewind the for loop by one, since there can be more possible compositions
  605.                     $i--;
  606.                     $out_len--;
  607.                     $last_class = ($i == $last_starter) ? 0 : $this->_get_combining_class($output[$i-1]);
  608.                     continue;
  609.                 }
  610.             }
  611.             // The current class is 0
  612.             if (!$class) $last_starter = $i;
  613.             $last_class = $class;
  614.         }
  615.         return $output;
  616.     }
  617.  
  618.     /**
  619.      * Decomposes a Hangul syllable
  620.      * (see http://www.unicode.org/unicode/reports/tr15/#Hangul
  621.      * @param    integer  32bit UCS4 code point
  622.      * @return   array    Either Hangul Syllable decomposed or original 32bit value as one value array
  623.      */
  624.     private function _hangul_decompose($char)
  625.     {
  626.         $sindex = (int) $char - $this->_sbase;
  627.         if ($sindex < 0 || $sindex >= $this->_scount) return array($char);
  628.         $result = array();
  629.         $result[] = (int) $this->_lbase + $sindex / $this->_ncount;
  630.         $result[] = (int) $this->_vbase + ($sindex % $this->_ncount) / $this->_tcount;
  631.         $T = intval($this->_tbase + $sindex % $this->_tcount);
  632.         if ($T != $this->_tbase) $result[] = $T;
  633.         return $result;
  634.     }
  635.     /**
  636.      * Ccomposes a Hangul syllable
  637.      * (see http://www.unicode.org/unicode/reports/tr15/#Hangul
  638.      * @param    array    Decomposed UCS4 sequence
  639.      * @return   array    UCS4 sequence with syllables composed
  640.      */
  641.     private function _hangul_compose($input)
  642.     {
  643.         $inp_len = count($input);
  644.         if (!$inp_len) return array();
  645.         $result = array();
  646.         $last = (int) $input[0];
  647.         $result[] = $last; // copy first char from input to output
  648.  
  649.         for ($i = 1; $i < $inp_len; ++$i) {
  650.             $char = (int) $input[$i];
  651.             $sindex = $last - $this->_sbase;
  652.             $lindex = $last - $this->_lbase;
  653.             $vindex = $char - $this->_vbase;
  654.             $tindex = $char - $this->_tbase;
  655.             // Find out, whether two current characters are LV and T
  656.             if (0 <= $sindex && $sindex < $this->_scount && ($sindex % $this->_tcount == 0)
  657.                     && 0 <= $tindex && $tindex <= $this->_tcount) {
  658.                 // create syllable of form LVT
  659.                 $last += $tindex;
  660.                 $result[(count($result) - 1)] = $last; // reset last
  661.                 continue; // discard char
  662.             }
  663.             // Find out, whether two current characters form L and V
  664.             if (0 <= $lindex && $lindex < $this->_lcount && 0 <= $vindex && $vindex < $this->_vcount) {
  665.                 // create syllable of form LV
  666.                 $last = (int) $this->_sbase + ($lindex * $this->_vcount + $vindex) * $this->_tcount;
  667.                 $result[(count($result) - 1)] = $last; // reset last
  668.                 continue; // discard char
  669.             }
  670.             // if neither case was true, just add the character
  671.             $last = $char;
  672.             $result[] = $char;
  673.         }
  674.         return $result;
  675.     }
  676.  
  677.     /**
  678.      * Returns the combining class of a certain wide char
  679.      * @param    integer    Wide char to check (32bit integer)
  680.      * @return   integer    Combining class if found, else 0
  681.      */
  682.     private function _get_combining_class($char)
  683.     {
  684.         return isset($this->NP['norm_combcls'][$char]) ? $this->NP['norm_combcls'][$char] : 0;
  685.     }
  686.  
  687.     /**
  688.      * Apllies the cannonical ordering of a decomposed UCS4 sequence
  689.      * @param    array      Decomposed UCS4 sequence
  690.      * @return   array      Ordered USC4 sequence
  691.      */
  692.     private function _apply_cannonical_ordering($input)
  693.     {
  694.         $swap = true;
  695.         $size = count($input);
  696.         while ($swap) {
  697.             $swap = false;
  698.             $last = $this->_get_combining_class(intval($input[0]));
  699.             for ($i = 0; $i < $size-1; ++$i) {
  700.                 $next = $this->_get_combining_class(intval($input[$i+1]));
  701.                 if ($next != 0 && $last > $next) {
  702.                     // Move item leftward until it fits
  703.                     for ($j = $i + 1; $j > 0; --$j) {
  704.                         if ($this->_get_combining_class(intval($input[$j-1])) <= $next) break;
  705.                         $t = intval($input[$j]);
  706.                         $input[$j] = intval($input[$j-1]);
  707.                         $input[$j-1] = $t;
  708.                         $swap = true;
  709.                     }
  710.                     // Reentering the loop looking at the old character again
  711.                     $next = $last;
  712.                 }
  713.                 $last = $next;
  714.             }
  715.         }
  716.         return $input;
  717.     }
  718.  
  719.     /**
  720.      * Do composition of a sequence of starter and non-starter
  721.      * @param    array      UCS4 Decomposed sequence
  722.      * @return   array      Ordered USC4 sequence
  723.      */
  724.     private function _combine($input)
  725.     {
  726.         $inp_len = count($input);
  727.         foreach ($this->NP['replacemaps'] as $np_src => $np_target) {
  728.             if ($np_target[0] != $input[0]) continue;
  729.             if (count($np_target) != $inp_len) continue;
  730.             $hit = false;
  731.             foreach ($input as $k2 => $v2) {
  732.                 if ($v2 == $np_target[$k2]) {
  733.                     $hit = true;
  734.                 } else {
  735.                     $hit = false;
  736.                     break;
  737.                 }
  738.             }
  739.             if ($hit) return $np_src;
  740.         }
  741.         return false;
  742.     }
  743.  
  744.     /**
  745.      * This converts an UTF-8 encoded string to its UCS-4 representation
  746.      * By talking about UCS-4 "strings" we mean arrays of 32bit integers representing
  747.      * each of the "chars". This is due to PHP not being able to handle strings with
  748.      * bit depth different from 8. This apllies to the reverse method _ucs4_to_utf8(), too.
  749.      * The following UTF-8 encodings are supported:
  750.      * bytes bits  representation
  751.      * 1        7  0xxxxxxx
  752.      * 2       11  110xxxxx 10xxxxxx
  753.      * 3       16  1110xxxx 10xxxxxx 10xxxxxx
  754.      * 4       21  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
  755.      * 5       26  111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  756.      * 6       31  1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  757.      * Each x represents a bit that can be used to store character data.
  758.      * The five and six byte sequences are part of Annex D of ISO/IEC 10646-1:2000
  759.      * @param string $input 
  760.      * @return string 
  761.      */
  762.     private function _utf8_to_ucs4($input)
  763.     {
  764.         $output = array();
  765.         $out_len = 0;
  766.         // Patch by Daniel Hahler; work around prolbem with mbstring.func_overload
  767.         if (function_exists('mb_strlen')) {
  768.             $inp_len = mb_strlen($input, '8bit');
  769.         } else {
  770.             $inp_len = strlen($input);
  771.         }
  772.         $mode = 'next';
  773.         $test = 'none';
  774.         for ($k = 0; $k < $inp_len; ++$k) {
  775.             $v = ord($input{$k}); // Extract byte from input string
  776.             if ($v < 128) { // We found an ASCII char - put into stirng as is
  777.                 $output[$out_len] = $v;
  778.                 ++$out_len;
  779.                 if ('add' == $mode) {
  780.                     $this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
  781.                     return false;
  782.                 }
  783.                 continue;
  784.             }
  785.             if ('next' == $mode) { // Try to find the next start byte; determine the width of the Unicode char
  786.                 $start_byte = $v;
  787.                 $mode = 'add';
  788.                 $test = 'range';
  789.                 if ($v >> 5 == 6) { // &110xxxxx 10xxxxx
  790.                     $next_byte = 0; // Tells, how many times subsequent bitmasks must rotate 6bits to the left
  791.                     $v = ($v - 192) << 6;
  792.                 } elseif ($v >> 4 == 14) { // &1110xxxx 10xxxxxx 10xxxxxx
  793.                     $next_byte = 1;
  794.                     $v = ($v - 224) << 12;
  795.                 } elseif ($v >> 3 == 30) { // &11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
  796.                     $next_byte = 2;
  797.                     $v = ($v - 240) << 18;
  798.                 } elseif ($v >> 2 == 62) { // &111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  799.                     $next_byte = 3;
  800.                     $v = ($v - 248) << 24;
  801.                 } elseif ($v >> 1 == 126) { // &1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  802.                     $next_byte = 4;
  803.                     $v = ($v - 252) << 30;
  804.                 } else {
  805.                     $this->_error('This might be UTF-8, but I don\'t understand it at byte '.$k);
  806.                     return false;
  807.                 }
  808.                 if ('add' == $mode) {
  809.                     $output[$out_len] = (int) $v;
  810.                     ++$out_len;
  811.                     continue;
  812.                 }
  813.             }
  814.             if ('add' == $mode) {
  815.                 if (!$this->_allow_overlong && $test == 'range') {
  816.                     $test = 'none';
  817.                     if (($v < 0xA0 && $start_byte == 0xE0) || ($v < 0x90 && $start_byte == 0xF0) || ($v > 0x8F && $start_byte == 0xF4)) {
  818.                         $this->_error('Bogus UTF-8 character detected (out of legal range) at byte '.$k);
  819.                         return false;
  820.                     }
  821.                 }
  822.                 if ($v >> 6 == 2) { // Bit mask must be 10xxxxxx
  823.                     $v = ($v - 128) << ($next_byte * 6);
  824.                     $output[($out_len - 1)] += $v;
  825.                     --$next_byte;
  826.                 } else {
  827.                     $this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
  828.                     return false;
  829.                 }
  830.                 if ($next_byte < 0) {
  831.                     $mode = 'next';
  832.                 }
  833.             }
  834.         } // for
  835.         return $output;
  836.     }
  837.  
  838.     /**
  839.      * Convert UCS-4 string into UTF-8 string
  840.      * See _utf8_to_ucs4() for details
  841.      * @param string  $input 
  842.      * @return string 
  843.      */
  844.     private function _ucs4_to_utf8($input)
  845.     {
  846.         $output = '';
  847.         foreach ($input as $k => $v) {
  848.             if ($v < 128) { // 7bit are transferred literally
  849.                 $output .= chr($v);
  850.             } elseif ($v < (1 << 11)) { // 2 bytes
  851.                 $output .= chr(192+($v >> 6)).chr(128+($v & 63));
  852.             } elseif ($v < (1 << 16)) { // 3 bytes
  853.                 $output .= chr(224+($v >> 12)).chr(128+(($v >> 6) & 63)).chr(128+($v & 63));
  854.             } elseif ($v < (1 << 21)) { // 4 bytes
  855.                 $output .= chr(240+($v >> 18)).chr(128+(($v >> 12) & 63)).chr(128+(($v >> 6) & 63)).chr(128+($v & 63));
  856.             } elseif (self::$safe_mode) {
  857.                 $output .= self::$safe_char;
  858.             } else {
  859.                 $this->_error('Conversion from UCS-4 to UTF-8 failed: malformed input at byte '.$k);
  860.                 return false;
  861.             }
  862.         }
  863.         return $output;
  864.     }
  865.  
  866.     /**
  867.       * Convert UCS-4 array into UCS-4 string
  868.       *
  869.       * @param array $input 
  870.       * @return string 
  871.       */
  872.     private function _ucs4_to_ucs4_string($input)
  873.     {
  874.         $output = '';
  875.         // Take array values and split output to 4 bytes per value
  876.         // The bit mask is 255, which reads &11111111
  877.         foreach ($input as $v) {
  878.             $output .= chr(($v >> 24) & 255).chr(($v >> 16) & 255).chr(($v >> 8) & 255).chr($v & 255);
  879.         }
  880.         return $output;
  881.     }
  882.  
  883.     /**
  884.       * Convert UCS-4 strin into UCS-4 garray
  885.       *
  886.       * @param  string $input 
  887.       * @return array 
  888.       */
  889.     private function _ucs4_string_to_ucs4($input)
  890.     {
  891.         $output = array();
  892.         $inp_len = strlen($input);
  893.         // Input length must be dividable by 4
  894.         if ($inp_len % 4) {
  895.             $this->_error('Input UCS4 string is broken');
  896.             return false;
  897.         }
  898.         // Empty input - return empty output
  899.         if (!$inp_len) return $output;
  900.         for ($i = 0, $out_len = -1; $i < $inp_len; ++$i) {
  901.             // Increment output position every 4 input bytes
  902.             if (!($i % 4)) {
  903.                 $out_len++;
  904.                 $output[$out_len] = 0;
  905.             }
  906.             $output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4) ) );
  907.         }
  908.         return $output;
  909.     }
  910.  
  911.     /**
  912.      * Holds all relevant mapping tables, loaded from a seperate file on construct
  913.      * See RFC3454 for details
  914.      *
  915.      * @private array
  916.      * @since 0.5.2
  917.      *
  918.      */
  919.     private $NP = array
  920.             ('map_nothing' => array
  921.                     (0xAD, 0x34F, 0x1806, 0x180B, 0x180C, 0x180D, 0x200B
  922.                     ,0x200C, 0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02, 0xFE03
  923.                     ,0xFE04, 0xFE05, 0xFE06, 0xFE07, 0xFE08, 0xFE09, 0xFE0A
  924.                     ,0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F, 0xFEFF
  925.                     )
  926.             ,'general_prohibited' => array
  927.                     (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE
  928.                     ,0xF, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17
  929.                     ,0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20
  930.                     ,0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29
  931.                     ,0x2A, 0x2B, 0x2C, 0x2F, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F
  932.                     ,0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x7B, 0x7C
  933.                     ,0x7D, 0x7E, 0x7F, 0x3002
  934.                     )
  935.             ,'prohibit' => array
  936.                     (0xA0, 0x340, 0x341, 0x6DD, 0x70F, 0x1680, 0x180E, 0x2000
  937.                     ,0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007
  938.                     ,0x2008, 0x2009, 0x200A, 0x200B, 0x200C, 0x200D, 0x200E
  939.                     ,0x200F, 0x2028, 0x2029, 0x202A, 0x202B, 0x202C, 0x202D
  940.                     ,0x202E, 0x202F, 0x205F, 0x206A, 0x206B, 0x206C, 0x206D
  941.                     ,0x206E, 0x206F, 0x3000, 0xFEFF, 0xFFF9, 0xFFFA, 0xFFFB
  942.                     ,0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF, 0x1FFFE, 0x1FFFF, 0x2FFFE
  943.                     ,0x2FFFF, 0x3FFFE, 0x3FFFF, 0x4FFFE, 0x4FFFF, 0x5FFFE
  944.                     ,0x5FFFF, 0x6FFFE, 0x6FFFF, 0x7FFFE, 0x7FFFF, 0x8FFFE
  945.                     ,0x8FFFF, 0x9FFFE, 0x9FFFF, 0xAFFFE, 0xAFFFF, 0xBFFFE
  946.                     ,0xBFFFF, 0xCFFFE, 0xCFFFF, 0xDFFFE, 0xDFFFF, 0xE0001
  947.                     ,0xEFFFE, 0xEFFFF, 0xFFFFE, 0xFFFFF, 0x10FFFE, 0x10FFFF
  948.                     )
  949.             ,'prohibit_ranges' => array
  950.                     (array(0x80, 0x9F), array(0x2060, 0x206F)
  951.                     ,array(0x1D173, 0x1D17A), array(0xE000, 0xF8FF)
  952.                     ,array(0xF0000, 0xFFFFD), array(0x100000, 0x10FFFD)
  953.                     ,array(0xFDD0, 0xFDEF), array(0xD800, 0xDFFF)
  954.                     ,array(0x2FF0, 0x2FFB), array(0xE0020, 0xE007F)
  955.                     )
  956.             ,'replacemaps' => array
  957.                     (0x41 => array(0x61)
  958.                     ,0x42 => array(0x62)
  959.                     ,0x43 => array(0x63)
  960.                     ,0x44 => array(0x64)
  961.                     ,0x45 => array(0x65)
  962.                     ,0x46 => array(0x66)
  963.                     ,0x47 => array(0x67)
  964.                     ,0x48 => array(0x68)
  965.                     ,0x49 => array(0x69)
  966.                     ,0x4A => array(0x6A)
  967.                     ,0x4B => array(0x6B)
  968.                     ,0x4C => array(0x6C)
  969.                     ,0x4D => array(0x6D)
  970.                     ,0x4E => array(0x6E)
  971.                     ,0x4F => array(0x6F)
  972.                     ,0x50 => array(0x70)
  973.                     ,0x51 => array(0x71)
  974.                     ,0x52 => array(0x72)
  975.                     ,0x53 => array(0x73)
  976.                     ,0x54 => array(0x74)
  977.                     ,0x55 => array(0x75)
  978.                     ,0x56 => array(0x76)
  979.                     ,0x57 => array(0x77)
  980.                     ,0x58 => array(0x78)
  981.                     ,0x59 => array(0x79)
  982.                     ,0x5A => array(0x7A)
  983.                     ,0xB5 => array(0x3BC)
  984.                     ,0xC0 => array(0xE0)
  985.                     ,0xC1 => array(0xE1)
  986.                     ,0xC2 => array(0xE2)
  987.                     ,0xC3 => array(0xE3)
  988.                     ,0xC4 => array(0xE4)
  989.                     ,0xC5 => array(0xE5)
  990.                     ,0xC6 => array(0xE6)
  991.                     ,0xC7 => array(0xE7)
  992.                     ,0xC8 => array(0xE8)
  993.                     ,0xC9 => array(0xE9)
  994.                     ,0xCA => array(0xEA)
  995.                     ,0xCB => array(0xEB)
  996.                     ,0xCC => array(0xEC)
  997.                     ,0xCD => array(0xED)
  998.                     ,0xCE => array(0xEE)
  999.                     ,0xCF => array(0xEF)
  1000.                     ,0xD0 => array(0xF0)
  1001.                     ,0xD1 => array(0xF1)
  1002.                     ,0xD2 => array(0xF2)
  1003.                     ,0xD3 => array(0xF3)
  1004.                     ,0xD4 => array(0xF4)
  1005.                     ,0xD5 => array(0xF5)
  1006.                     ,0xD6 => array(0xF6)
  1007.                     ,0xD8 => array(0xF8)
  1008.                     ,0xD9 => array(0xF9)
  1009.                     ,0xDA => array(0xFA)
  1010.                     ,0xDB => array(0xFB)
  1011.                     ,0xDC => array(0xFC)
  1012.                     ,0xDD => array(0xFD)
  1013.                     ,0xDE => array(0xFE)
  1014.                     ,0xDF => array(0x73, 0x73)
  1015.                     ,0x100 => array(0x101)
  1016.                     ,0x102 => array(0x103)
  1017.                     ,0x104 => array(0x105)
  1018.                     ,0x106 => array(0x107)
  1019.                     ,0x108 => array(0x109)
  1020.                     ,0x10A => array(0x10B)
  1021.                     ,0x10C => array(0x10D)
  1022.                     ,0x10E => array(0x10F)
  1023.                     ,0x110 => array(0x111)
  1024.                     ,0x112 => array(0x113)
  1025.                     ,0x114 => array(0x115)
  1026.                     ,0x116 => array(0x117)
  1027.                     ,0x118 => array(0x119)
  1028.                     ,0x11A => array(0x11B)
  1029.                     ,0x11C => array(0x11D)
  1030.                     ,0x11E => array(0x11F)
  1031.                     ,0x120 => array(0x121)
  1032.                     ,0x122 => array(0x123)
  1033.                     ,0x124 => array(0x125)
  1034.                     ,0x126 => array(0x127)
  1035.                     ,0x128 => array(0x129)
  1036.                     ,0x12A => array(0x12B)
  1037.                     ,0x12C => array(0x12D)
  1038.                     ,0x12E => array(0x12F)
  1039.                     ,0x130 => array(0x69, 0x307)
  1040.                     ,0x132 => array(0x133)
  1041.                     ,0x134 => array(0x135)
  1042.                     ,0x136 => array(0x137)
  1043.                     ,0x139 => array(0x13A)
  1044.                     ,0x13B => array(0x13C)
  1045.                     ,0x13D => array(0x13E)
  1046.                     ,0x13F => array(0x140)
  1047.                     ,0x141 => array(0x142)
  1048.                     ,0x143 => array(0x144)
  1049.                     ,0x145 => array(0x146)
  1050.                     ,0x147 => array(0x148)
  1051.                     ,0x149 => array(0x2BC, 0x6E)
  1052.                     ,0x14A => array(0x14B)
  1053.                     ,0x14C => array(0x14D)
  1054.                     ,0x14E => array(0x14F)
  1055.                     ,0x150 => array(0x151)
  1056.                     ,0x152 => array(0x153)
  1057.                     ,0x154 => array(0x155)
  1058.                     ,0x156 => array(0x157)
  1059.                     ,0x158 => array(0x159)
  1060.                     ,0x15A => array(0x15B)
  1061.                     ,0x15C => array(0x15D)
  1062.                     ,0x15E => array(0x15F)
  1063.                     ,0x160 => array(0x161)
  1064.                     ,0x162 => array(0x163)
  1065.                     ,0x164 => array(0x165)
  1066.                     ,0x166 => array(0x167)
  1067.                     ,0x168 => array(0x169)
  1068.                     ,0x16A => array(0x16B)
  1069.                     ,0x16C => array(0x16D)
  1070.                     ,0x16E => array(0x16F)
  1071.                     ,0x170 => array(0x171)
  1072.                     ,0x172 => array(0x173)
  1073.                     ,0x174 => array(0x175)
  1074.                     ,0x176 => array(0x177)
  1075.                     ,0x178 => array(0xFF)
  1076.                     ,0x179 => array(0x17A)
  1077.                     ,0x17B => array(0x17C)
  1078.                     ,0x17D => array(0x17E)
  1079.                     ,0x17F => array(0x73)
  1080.                     ,0x181 => array(0x253)
  1081.                     ,0x182 => array(0x183)
  1082.                     ,0x184 => array(0x185)
  1083.                     ,0x186 => array(0x254)
  1084.                     ,0x187 => array(0x188)
  1085.                     ,0x189 => array(0x256)
  1086.                     ,0x18A => array(0x257)
  1087.                     ,0x18B => array(0x18C)
  1088.                     ,0x18E => array(0x1DD)
  1089.                     ,0x18F => array(0x259)
  1090.                     ,0x190 => array(0x25B)
  1091.                     ,0x191 => array(0x192)
  1092.                     ,0x193 => array(0x260)
  1093.                     ,0x194 => array(0x263)
  1094.                     ,0x196 => array(0x269)
  1095.                     ,0x197 => array(0x268)
  1096.                     ,0x198 => array(0x199)
  1097.                     ,0x19C => array(0x26F)
  1098.                     ,0x19D => array(0x272)
  1099.                     ,0x19F => array(0x275)
  1100.                     ,0x1A0 => array(0x1A1)
  1101.                     ,0x1A2 => array(0x1A3)
  1102.                     ,0x1A4 => array(0x1A5)
  1103.                     ,0x1A6 => array(0x280)
  1104.                     ,0x1A7 => array(0x1A8)
  1105.                     ,0x1A9 => array(0x283)
  1106.                     ,0x1AC => array(0x1AD)
  1107.                     ,0x1AE => array(0x288)
  1108.                     ,0x1AF => array(0x1B0)
  1109.                     ,0x1B1 => array(0x28A)
  1110.                     ,0x1B2 => array(0x28B)
  1111.                     ,0x1B3 => array(0x1B4)
  1112.                     ,0x1B5 => array(0x1B6)
  1113.                     ,0x1B7 => array(0x292)
  1114.                     ,0x1B8 => array(0x1B9)
  1115.                     ,0x1BC => array(0x1BD)
  1116.                     ,0x1C4 => array(0x1C6)
  1117.                     ,0x1C5 => array(0x1C6)
  1118.                     ,0x1C7 => array(0x1C9)
  1119.                     ,0x1C8 => array(0x1C9)
  1120.                     ,0x1CA => array(0x1CC)
  1121.                     ,0x1CB => array(0x1CC)
  1122.                     ,0x1CD => array(0x1CE)
  1123.                     ,0x1CF => array(0x1D0)
  1124.                     ,0x1D1   => array(0x1D2)
  1125.                     ,0x1D3   => array(0x1D4)
  1126.                     ,0x1D5   => array(0x1D6)
  1127.                     ,0x1D7   => array(0x1D8)
  1128.                     ,0x1D9   => array(0x1DA)
  1129.                     ,0x1DB   => array(0x1DC)
  1130.                     ,0x1DE   => array(0x1DF)
  1131.                     ,0x1E0   => array(0x1E1)
  1132.                     ,0x1E2   => array(0x1E3)
  1133.                     ,0x1E4   => array(0x1E5)
  1134.                     ,0x1E6   => array(0x1E7)
  1135.                     ,0x1E8   => array(0x1E9)
  1136.                     ,0x1EA   => array(0x1EB)
  1137.                     ,0x1EC   => array(0x1ED)
  1138.                     ,0x1EE   => array(0x1EF)
  1139.                     ,0x1F0   => array(0x6A, 0x30C)
  1140.                     ,0x1F1   => array(0x1F3)
  1141.                     ,0x1F2   => array(0x1F3)
  1142.                     ,0x1F4   => array(0x1F5)
  1143.                     ,0x1F6   => array(0x195)
  1144.                     ,0x1F7   => array(0x1BF)
  1145.                     ,0x1F8   => array(0x1F9)
  1146.                     ,0x1FA   => array(0x1FB)
  1147.                     ,0x1FC   => array(0x1FD)
  1148.                     ,0x1FE   => array(0x1FF)
  1149.                     ,0x200   => array(0x201)
  1150.                     ,0x202   => array(0x203)
  1151.                     ,0x204   => array(0x205)
  1152.                     ,0x206   => array(0x207)
  1153.                     ,0x208   => array(0x209)
  1154.                     ,0x20A   => array(0x20B)
  1155.                     ,0x20C   => array(0x20D)
  1156.                     ,0x20E   => array(0x20F)
  1157.                     ,0x210   => array(0x211)
  1158.                     ,0x212   => array(0x213)
  1159.                     ,0x214   => array(0x215)
  1160.                     ,0x216   => array(0x217)
  1161.                     ,0x218   => array(0x219)
  1162.                     ,0x21A   => array(0x21B)
  1163.                     ,0x21C   => array(0x21D)
  1164.                     ,0x21E   => array(0x21F)
  1165.                     ,0x220   => array(0x19E)
  1166.                     ,0x222   => array(0x223)
  1167.                     ,0x224   => array(0x225)
  1168.                     ,0x226   => array(0x227)
  1169.                     ,0x228   => array(0x229)
  1170.                     ,0x22A   => array(0x22B)
  1171.                     ,0x22C   => array(0x22D)
  1172.                     ,0x22E   => array(0x22F)
  1173.                     ,0x230   => array(0x231)
  1174.                     ,0x232   => array(0x233)
  1175.                     ,0x345   => array(0x3B9)
  1176.                     ,0x37A   => array(0x20, 0x3B9)
  1177.                     ,0x386   => array(0x3AC)
  1178.                     ,0x388   => array(0x3AD)
  1179.                     ,0x389   => array(0x3AE)
  1180.                     ,0x38A   => array(0x3AF)
  1181.                     ,0x38C   => array(0x3CC)
  1182.                     ,0x38E   => array(0x3CD)
  1183.                     ,0x38F   => array(0x3CE)
  1184.                     ,0x390   => array(0x3B9, 0x308, 0x301)
  1185.                     ,0x391   => array(0x3B1)
  1186.                     ,0x392   => array(0x3B2)
  1187.                     ,0x393   => array(0x3B3)
  1188.                     ,0x394   => array(0x3B4)
  1189.                     ,0x395   => array(0x3B5)
  1190.                     ,0x396   => array(0x3B6)
  1191.                     ,0x397   => array(0x3B7)
  1192.                     ,0x398   => array(0x3B8)
  1193.                     ,0x399   => array(0x3B9)
  1194.                     ,0x39A   => array(0x3BA)
  1195.                     ,0x39B   => array(0x3BB)
  1196.                     ,0x39C   => array(0x3BC)
  1197.                     ,0x39D   => array(0x3BD)
  1198.                     ,0x39E   => array(0x3BE)
  1199.                     ,0x39F   => array(0x3BF)
  1200.                     ,0x3A0   => array(0x3C0)
  1201.                     ,0x3A1   => array(0x3C1)
  1202.                     ,0x3A3   => array(0x3C3)
  1203.                     ,0x3A4   => array(0x3C4)
  1204.                     ,0x3A5   => array(0x3C5)
  1205.                     ,0x3A6   => array(0x3C6)
  1206.                     ,0x3A7   => array(0x3C7)
  1207.                     ,0x3A8   => array(0x3C8)
  1208.                     ,0x3A9   => array(0x3C9)
  1209.                     ,0x3AA   => array(0x3CA)
  1210.                     ,0x3AB   => array(0x3CB)
  1211.                     ,0x3B0   => array(0x3C5, 0x308, 0x301)
  1212.                     ,0x3C2   => array(0x3C3)
  1213.                     ,0x3D0   => array(0x3B2)
  1214.                     ,0x3D1   => array(0x3B8)
  1215.                     ,0x3D2   => array(0x3C5)
  1216.                     ,0x3D3   => array(0x3CD)
  1217.                     ,0x3D4   => array(0x3CB)
  1218.                     ,0x3D5   => array(0x3C6)
  1219.                     ,0x3D6   => array(0x3C0)
  1220.                     ,0x3D8   => array(0x3D9)
  1221.                     ,0x3DA   => array(0x3DB)
  1222.                     ,0x3DC   => array(0x3DD)
  1223.                     ,0x3DE   => array(0x3DF)
  1224.                     ,0x3E0   => array(0x3E1)
  1225.                     ,0x3E2   => array(0x3E3)
  1226.                     ,0x3E4   => array(0x3E5)
  1227.                     ,0x3E6   => array(0x3E7)
  1228.                     ,0x3E8   => array(0x3E9)
  1229.                     ,0x3EA   => array(0x3EB)
  1230.                     ,0x3EC   => array(0x3ED)
  1231.                     ,0x3EE   => array(0x3EF)
  1232.                     ,0x3F0   => array(0x3BA)
  1233.                     ,0x3F1   => array(0x3C1)
  1234.                     ,0x3F2   => array(0x3C3)
  1235.                     ,0x3F4   => array(0x3B8)
  1236.                     ,0x3F5   => array(0x3B5)
  1237.                     ,0x400   => array(0x450)
  1238.                     ,0x401   => array(0x451)
  1239.                     ,0x402   => array(0x452)
  1240.                     ,0x403   => array(0x453)
  1241.                     ,0x404   => array(0x454)
  1242.                     ,0x405   => array(0x455)
  1243.                     ,0x406   => array(0x456)
  1244.                     ,0x407   => array(0x457)
  1245.                     ,0x408   => array(0x458)
  1246.                     ,0x409   => array(0x459)
  1247.                     ,0x40A   => array(0x45A)
  1248.                     ,0x40B   => array(0x45B)
  1249.                     ,0x40C   => array(0x45C)
  1250.                     ,0x40D   => array(0x45D)
  1251.                     ,0x40E   => array(0x45E)
  1252.                     ,0x40F   => array(0x45F)
  1253.                     ,0x410   => array(0x430)
  1254.                     ,0x411   => array(0x431)
  1255.                     ,0x412   => array(0x432)
  1256.                     ,0x413   => array(0x433)
  1257.                     ,0x414   => array(0x434)
  1258.                     ,0x415   => array(0x435)
  1259.                     ,0x416   => array(0x436)
  1260.                     ,0x417   => array(0x437)
  1261.                     ,0x418   => array(0x438)
  1262.                     ,0x419   => array(0x439)
  1263.                     ,0x41A   => array(0x43A)
  1264.                     ,0x41B   => array(0x43B)
  1265.                     ,0x41C   => array(0x43C)
  1266.                     ,0x41D   => array(0x43D)
  1267.                     ,0x41E   => array(0x43E)
  1268.                     ,0x41F   => array(0x43F)
  1269.                     ,0x420   => array(0x440)
  1270.                     ,0x421   => array(0x441)
  1271.                     ,0x422   => array(0x442)
  1272.                     ,0x423   => array(0x443)
  1273.                     ,0x424   => array(0x444)
  1274.                     ,0x425   => array(0x445)
  1275.                     ,0x426   => array(0x446)
  1276.                     ,0x427   => array(0x447)
  1277.                     ,0x428   => array(0x448)
  1278.                     ,0x429   => array(0x449)
  1279.                     ,0x42A   => array(0x44A)
  1280.                     ,0x42B   => array(0x44B)
  1281.                     ,0x42C   => array(0x44C)
  1282.                     ,0x42D   => array(0x44D)
  1283.                     ,0x42E   => array(0x44E)
  1284.                     ,0x42F   => array(0x44F)
  1285.                     ,0x460   => array(0x461)
  1286.                     ,0x462   => array(0x463)
  1287.                     ,0x464   => array(0x465)
  1288.                     ,0x466   => array(0x467)
  1289.                     ,0x468   => array(0x469)
  1290.                     ,0x46A   => array(0x46B)
  1291.                     ,0x46C   => array(0x46D)
  1292.                     ,0x46E   => array(0x46F)
  1293.                     ,0x470   => array(0x471)
  1294.                     ,0x472   => array(0x473)
  1295.                     ,0x474   => array(0x475)
  1296.                     ,0x476   => array(0x477)
  1297.                     ,0x478   => array(0x479)
  1298.                     ,0x47A   => array(0x47B)
  1299.                     ,0x47C   => array(0x47D)
  1300.                     ,0x47E   => array(0x47F)
  1301.                     ,0x480   => array(0x481)
  1302.                     ,0x48A   => array(0x48B)
  1303.                     ,0x48C   => array(0x48D)
  1304.                     ,0x48E   => array(0x48F)
  1305.                     ,0x490   => array(0x491)
  1306.                     ,0x492   => array(0x493)
  1307.                     ,0x494   => array(0x495)
  1308.                     ,0x496   => array(0x497)
  1309.                     ,0x498   => array(0x499)
  1310.                     ,0x49A   => array(0x49B)
  1311.                     ,0x49C   => array(0x49D)
  1312.                     ,0x49E   => array(0x49F)
  1313.                     ,0x4A0   => array(0x4A1)
  1314.                     ,0x4A2   => array(0x4A3)
  1315.                     ,0x4A4   => array(0x4A5)
  1316.                     ,0x4A6   => array(0x4A7)
  1317.                     ,0x4A8   => array(0x4A9)
  1318.                     ,0x4AA   => array(0x4AB)
  1319.                     ,0x4AC   => array(0x4AD)
  1320.                     ,0x4AE   => array(0x4AF)
  1321.                     ,0x4B0   => array(0x4B1)
  1322.                     ,0x4B2   => array(0x4B3)
  1323.                     ,0x4B4   => array(0x4B5)
  1324.                     ,0x4B6   => array(0x4B7)
  1325.                     ,0x4B8   => array(0x4B9)
  1326.                     ,0x4BA   => array(0x4BB)
  1327.                     ,0x4BC   => array(0x4BD)
  1328.                     ,0x4BE   => array(0x4BF)
  1329.                     ,0x4C1   => array(0x4C2)
  1330.                     ,0x4C3   => array(0x4C4)
  1331.                     ,0x4C5   => array(0x4C6)
  1332.                     ,0x4C7   => array(0x4C8)
  1333.                     ,0x4C9   => array(0x4CA)
  1334.                     ,0x4CB   => array(0x4CC)
  1335.                     ,0x4CD   => array(0x4CE)
  1336.                     ,0x4D0   => array(0x4D1)
  1337.                     ,0x4D2   => array(0x4D3)
  1338.                     ,0x4D4   => array(0x4D5)
  1339.                     ,0x4D6   => array(0x4D7)
  1340.                     ,0x4D8   => array(0x4D9)
  1341.                     ,0x4DA   => array(0x4DB)
  1342.                     ,0x4DC   => array(0x4DD)
  1343.                     ,0x4DE   => array(0x4DF)
  1344.                     ,0x4E0   => array(0x4E1)
  1345.                     ,0x4E2   => array(0x4E3)
  1346.                     ,0x4E4   => array(0x4E5)
  1347.                     ,0x4E6   => array(0x4E7)
  1348.                     ,0x4E8   => array(0x4E9)
  1349.                     ,0x4EA   => array(0x4EB)
  1350.                     ,0x4EC   => array(0x4ED)
  1351.                     ,0x4EE   => array(0x4EF)
  1352.                     ,0x4F0   => array(0x4F1)
  1353.                     ,0x4F2   => array(0x4F3)
  1354.                     ,0x4F4   => array(0x4F5)
  1355.                     ,0x4F8   => array(0x4F9)
  1356.                     ,0x500   => array(0x501)
  1357.                     ,0x502   => array(0x503)
  1358.                     ,0x504   => array(0x505)
  1359.                     ,0x506   => array(0x507)
  1360.                     ,0x508   => array(0x509)
  1361.                     ,0x50A   => array(0x50B)
  1362.                     ,0x50C   => array(0x50D)
  1363.                     ,0x50E   => array(0x50F)
  1364.                     ,0x531   => array(0x561)
  1365.                     ,0x532   => array(0x562)
  1366.                     ,0x533   => array(0x563)
  1367.                     ,0x534   => array(0x564)
  1368.                     ,0x535   => array(0x565)
  1369.                     ,0x536   => array(0x566)
  1370.                     ,0x537   => array(0x567)
  1371.                     ,0x538   => array(0x568)
  1372.                     ,0x539   => array(0x569)
  1373.                     ,0x53A   => array(0x56A)
  1374.                     ,0x53B   => array(0x56B)
  1375.                     ,0x53C   => array(0x56C)
  1376.                     ,0x53D   => array(0x56D)
  1377.                     ,0x53E   => array(0x56E)
  1378.                     ,0x53F   => array(0x56F)
  1379.                     ,0x540   => array(0x570)
  1380.                     ,0x541   => array(0x571)
  1381.                     ,0x542   => array(0x572)
  1382.                     ,0x543   => array(0x573)
  1383.                     ,0x544   => array(0x574)
  1384.                     ,0x545   => array(0x575)
  1385.                     ,0x546   => array(0x576)
  1386.                     ,0x547   => array(0x577)
  1387.                     ,0x548   => array(0x578)
  1388.                     ,0x549   => array(0x579)
  1389.                     ,0x54A   => array(0x57A)
  1390.                     ,0x54B   => array(0x57B)
  1391.                     ,0x54C   => array(0x57C)
  1392.                     ,0x54D   => array(0x57D)
  1393.                     ,0x54E   => array(0x57E)
  1394.                     ,0x54F   => array(0x57F)
  1395.                     ,0x550   => array(0x580)
  1396.                     ,0x551   => array(0x581)
  1397.                     ,0x552   => array(0x582)
  1398.                     ,0x553   => array(0x583)
  1399.                     ,0x554   => array(0x584)
  1400.                     ,0x555   => array(0x585)
  1401.                     ,0x556   => array(0x586)
  1402.                     ,0x587   => array(0x565, 0x582)
  1403.                     ,0x1E00  => array(0x1E01)
  1404.                     ,0x1E02  => array(0x1E03)
  1405.                     ,0x1E04  => array(0x1E05)
  1406.                     ,0x1E06  => array(0x1E07)
  1407.                     ,0x1E08  => array(0x1E09)
  1408.                     ,0x1E0A  => array(0x1E0B)
  1409.                     ,0x1E0C  => array(0x1E0D)
  1410.                     ,0x1E0E  => array(0x1E0F)
  1411.                     ,0x1E10  => array(0x1E11)
  1412.                     ,0x1E12  => array(0x1E13)
  1413.                     ,0x1E14  => array(0x1E15)
  1414.                     ,0x1E16  => array(0x1E17)
  1415.                     ,0x1E18  => array(0x1E19)
  1416.                     ,0x1E1A  => array(0x1E1B)
  1417.                     ,0x1E1C  => array(0x1E1D)
  1418.                     ,0x1E1E  => array(0x1E1F)
  1419.                     ,0x1E20  => array(0x1E21)
  1420.                     ,0x1E22  => array(0x1E23)
  1421.                     ,0x1E24  => array(0x1E25)
  1422.                     ,0x1E26  => array(0x1E27)
  1423.                     ,0x1E28  => array(0x1E29)
  1424.                     ,0x1E2A  => array(0x1E2B)
  1425.                     ,0x1E2C  => array(0x1E2D)
  1426.                     ,0x1E2E  => array(0x1E2F)
  1427.                     ,0x1E30  => array(0x1E31)
  1428.                     ,0x1E32  => array(0x1E33)
  1429.                     ,0x1E34  => array(0x1E35)
  1430.                     ,0x1E36  => array(0x1E37)
  1431.                     ,0x1E38  => array(0x1E39)
  1432.                     ,0x1E3A  => array(0x1E3B)
  1433.                     ,0x1E3C  => array(0x1E3D)
  1434.                     ,0x1E3E  => array(0x1E3F)
  1435.                     ,0x1E40  => array(0x1E41)
  1436.                     ,0x1E42  => array(0x1E43)
  1437.                     ,0x1E44  => array(0x1E45)
  1438.                     ,0x1E46  => array(0x1E47)
  1439.                     ,0x1E48  => array(0x1E49)
  1440.                     ,0x1E4A  => array(0x1E4B)
  1441.                     ,0x1E4C  => array(0x1E4D)
  1442.                     ,0x1E4E  => array(0x1E4F)
  1443.                     ,0x1E50  => array(0x1E51)
  1444.                     ,0x1E52  => array(0x1E53)
  1445.                     ,0x1E54  => array(0x1E55)
  1446.                     ,0x1E56  => array(0x1E57)
  1447.                     ,0x1E58  => array(0x1E59)
  1448.                     ,0x1E5A  => array(0x1E5B)
  1449.                     ,0x1E5C  => array(0x1E5D)
  1450.                     ,0x1E5E  => array(0x1E5F)
  1451.                     ,0x1E60  => array(0x1E61)
  1452.                     ,0x1E62  => array(0x1E63)
  1453.                     ,0x1E64  => array(0x1E65)
  1454.                     ,0x1E66  => array(0x1E67)
  1455.                     ,0x1E68  => array(0x1E69)
  1456.                     ,0x1E6A  => array(0x1E6B)
  1457.                     ,0x1E6C  => array(0x1E6D)
  1458.                     ,0x1E6E  => array(0x1E6F)
  1459.                     ,0x1E70  => array(0x1E71)
  1460.                     ,0x1E72  => array(0x1E73)
  1461.                     ,0x1E74  => array(0x1E75)
  1462.                     ,0x1E76  => array(0x1E77)
  1463.                     ,0x1E78  => array(0x1E79)
  1464.                     ,0x1E7A  => array(0x1E7B)
  1465.                     ,0x1E7C  => array(0x1E7D)
  1466.                     ,0x1E7E  => array(0x1E7F)
  1467.                     ,0x1E80  => array(0x1E81)
  1468.                     ,0x1E82  => array(0x1E83)
  1469.                     ,0x1E84  => array(0x1E85)
  1470.                     ,0x1E86  => array(0x1E87)
  1471.                     ,0x1E88  => array(0x1E89)
  1472.                     ,0x1E8A  => array(0x1E8B)
  1473.                     ,0x1E8C  => array(0x1E8D)
  1474.                     ,0x1E8E  => array(0x1E8F)
  1475.                     ,0x1E90  => array(0x1E91)
  1476.                     ,0x1E92  => array(0x1E93)
  1477.                     ,0x1E94  => array(0x1E95)
  1478.                     ,0x1E96  => array(0x68, 0x331)
  1479.                     ,0x1E97  => array(0x74, 0x308)
  1480.                     ,0x1E98  => array(0x77, 0x30A)
  1481.                     ,0x1E99  => array(0x79, 0x30A)
  1482.                     ,0x1E9A  => array(0x61, 0x2BE)
  1483.                     ,0x1E9B  => array(0x1E61)
  1484.                     ,0x1EA0  => array(0x1EA1)
  1485.                     ,0x1EA2  => array(0x1EA3)
  1486.                     ,0x1EA4  => array(0x1EA5)
  1487.                     ,0x1EA6  => array(0x1EA7)
  1488.                     ,0x1EA8  => array(0x1EA9)
  1489.                     ,0x1EAA  => array(0x1EAB)
  1490.                     ,0x1EAC  => array(0x1EAD)
  1491.                     ,0x1EAE  => array(0x1EAF)
  1492.                     ,0x1EB0  => array(0x1EB1)
  1493.                     ,0x1EB2  => array(0x1EB3)
  1494.                     ,0x1EB4  => array(0x1EB5)
  1495.                     ,0x1EB6  => array(0x1EB7)
  1496.                     ,0x1EB8  => array(0x1EB9)
  1497.                     ,0x1EBA  => array(0x1EBB)
  1498.                     ,0x1EBC  => array(0x1EBD)
  1499.                     ,0x1EBE  => array(0x1EBF)
  1500.                     ,0x1EC0  => array(0x1EC1)
  1501.                     ,0x1EC2  => array(0x1EC3)
  1502.                     ,0x1EC4  => array(0x1EC5)
  1503.                     ,0x1EC6  => array(0x1EC7)
  1504.                     ,0x1EC8  => array(0x1EC9)
  1505.                     ,0x1ECA  => array(0x1ECB)
  1506.                     ,0x1ECC  => array(0x1ECD)
  1507.                     ,0x1ECE  => array(0x1ECF)
  1508.                     ,0x1ED0  => array(0x1ED1)
  1509.                     ,0x1ED2  => array(0x1ED3)
  1510.                     ,0x1ED4  => array(0x1ED5)
  1511.                     ,0x1ED6  => array(0x1ED7)
  1512.                     ,0x1ED8  => array(0x1ED9)
  1513.                     ,0x1EDA  => array(0x1EDB)
  1514.                     ,0x1EDC  => array(0x1EDD)
  1515.                     ,0x1EDE  => array(0x1EDF)
  1516.                     ,0x1EE0  => array(0x1EE1)
  1517.                     ,0x1EE2  => array(0x1EE3)
  1518.                     ,0x1EE4  => array(0x1EE5)
  1519.                     ,0x1EE6  => array(0x1EE7)
  1520.                     ,0x1EE8  => array(0x1EE9)
  1521.                     ,0x1EEA  => array(0x1EEB)
  1522.                     ,0x1EEC  => array(0x1EED)
  1523.                     ,0x1EEE  => array(0x1EEF)
  1524.                     ,0x1EF0  => array(0x1EF1)
  1525.                     ,0x1EF2  => array(0x1EF3)
  1526.                     ,0x1EF4  => array(0x1EF5)
  1527.                     ,0x1EF6  => array(0x1EF7)
  1528.                     ,0x1EF8  => array(0x1EF9)
  1529.                     ,0x1F08  => array(0x1F00)
  1530.                     ,0x1F09  => array(0x1F01)
  1531.                     ,0x1F0A  => array(0x1F02)
  1532.                     ,0x1F0B  => array(0x1F03)
  1533.                     ,0x1F0C  => array(0x1F04)
  1534.                     ,0x1F0D  => array(0x1F05)
  1535.                     ,0x1F0E  => array(0x1F06)
  1536.                     ,0x1F0F  => array(0x1F07)
  1537.                     ,0x1F18  => array(0x1F10)
  1538.                     ,0x1F19  => array(0x1F11)
  1539.                     ,0x1F1A  => array(0x1F12)
  1540.                     ,0x1F1B  => array(0x1F13)
  1541.                     ,0x1F1C  => array(0x1F14)
  1542.                     ,0x1F1D  => array(0x1F15)
  1543.                     ,0x1F28  => array(0x1F20)
  1544.                     ,0x1F29  => array(0x1F21)
  1545.                     ,0x1F2A  => array(0x1F22)
  1546.                     ,0x1F2B  => array(0x1F23)
  1547.                     ,0x1F2C  => array(0x1F24)
  1548.                     ,0x1F2D  => array(0x1F25)
  1549.                     ,0x1F2E  => array(0x1F26)
  1550.                     ,0x1F2F  => array(0x1F27)
  1551.                     ,0x1F38  => array(0x1F30)
  1552.                     ,0x1F39  => array(0x1F31)
  1553.                     ,0x1F3A  => array(0x1F32)
  1554.                     ,0x1F3B  => array(0x1F33)
  1555.                     ,0x1F3C  => array(0x1F34)
  1556.                     ,0x1F3D  => array(0x1F35)
  1557.                     ,0x1F3E  => array(0x1F36)
  1558.                     ,0x1F3F  => array(0x1F37)
  1559.                     ,0x1F48  => array(0x1F40)
  1560.                     ,0x1F49  => array(0x1F41)
  1561.                     ,0x1F4A  => array(0x1F42)
  1562.                     ,0x1F4B  => array(0x1F43)
  1563.                     ,0x1F4C  => array(0x1F44)
  1564.                     ,0x1F4D  => array(0x1F45)
  1565.                     ,0x1F50  => array(0x3C5, 0x313)
  1566.                     ,0x1F52  => array(0x3C5, 0x313, 0x300)
  1567.                     ,0x1F54  => array(0x3C5, 0x313, 0x301)
  1568.                     ,0x1F56  => array(0x3C5, 0x313, 0x342)
  1569.                     ,0x1F59  => array(0x1F51)
  1570.                     ,0x1F5B  => array(0x1F53)
  1571.                     ,0x1F5D  => array(0x1F55)
  1572.                     ,0x1F5F  => array(0x1F57)
  1573.                     ,0x1F68  => array(0x1F60)
  1574.                     ,0x1F69  => array(0x1F61)
  1575.                     ,0x1F6A  => array(0x1F62)
  1576.                     ,0x1F6B  => array(0x1F63)
  1577.                     ,0x1F6C  => array(0x1F64)
  1578.                     ,0x1F6D  => array(0x1F65)
  1579.                     ,0x1F6E  => array(0x1F66)
  1580.                     ,0x1F6F  => array(0x1F67)
  1581.                     ,0x1F80  => array(0x1F00, 0x3B9)
  1582.                     ,0x1F81  => array(0x1F01, 0x3B9)
  1583.                     ,0x1F82  => array(0x1F02, 0x3B9)
  1584.                     ,0x1F83  => array(0x1F03, 0x3B9)
  1585.                     ,0x1F84  => array(0x1F04, 0x3B9)
  1586.                     ,0x1F85  => array(0x1F05, 0x3B9)
  1587.                     ,0x1F86  => array(0x1F06, 0x3B9)
  1588.                     ,0x1F87  => array(0x1F07, 0x3B9)
  1589.                     ,0x1F88  => array(0x1F00, 0x3B9)
  1590.                     ,0x1F89  => array(0x1F01, 0x3B9)
  1591.                     ,0x1F8A  => array(0x1F02, 0x3B9)
  1592.                     ,0x1F8B  => array(0x1F03, 0x3B9)
  1593.                     ,0x1F8C  => array(0x1F04, 0x3B9)
  1594.                     ,0x1F8D  => array(0x1F05, 0x3B9)
  1595.                     ,0x1F8E  => array(0x1F06, 0x3B9)
  1596.                     ,0x1F8F  => array(0x1F07, 0x3B9)
  1597.                     ,0x1F90  => array(0x1F20, 0x3B9)
  1598.                     ,0x1F91  => array(0x1F21, 0x3B9)
  1599.                     ,0x1F92  => array(0x1F22, 0x3B9)
  1600.                     ,0x1F93  => array(0x1F23, 0x3B9)
  1601.                     ,0x1F94  => array(0x1F24, 0x3B9)
  1602.                     ,0x1F95  => array(0x1F25, 0x3B9)
  1603.                     ,0x1F96  => array(0x1F26, 0x3B9)
  1604.                     ,0x1F97  => array(0x1F27, 0x3B9)
  1605.                     ,0x1F98  => array(0x1F20, 0x3B9)
  1606.                     ,0x1F99  => array(0x1F21, 0x3B9)
  1607.                     ,0x1F9A  => array(0x1F22, 0x3B9)
  1608.                     ,0x1F9B  => array(0x1F23, 0x3B9)
  1609.                     ,0x1F9C  => array(0x1F24, 0x3B9)
  1610.                     ,0x1F9D  => array(0x1F25, 0x3B9)
  1611.                     ,0x1F9E  => array(0x1F26, 0x3B9)
  1612.                     ,0x1F9F  => array(0x1F27, 0x3B9)
  1613.                     ,0x1FA0  => array(0x1F60, 0x3B9)
  1614.                     ,0x1FA1  => array(0x1F61, 0x3B9)
  1615.                     ,0x1FA2  => array(0x1F62, 0x3B9)
  1616.                     ,0x1FA3  => array(0x1F63, 0x3B9)
  1617.                     ,0x1FA4  => array(0x1F64, 0x3B9)
  1618.                     ,0x1FA5  => array(0x1F65, 0x3B9)
  1619.                     ,0x1FA6  => array(0x1F66, 0x3B9)
  1620.                     ,0x1FA7  => array(0x1F67, 0x3B9)
  1621.                     ,0x1FA8  => array(0x1F60, 0x3B9)
  1622.                     ,0x1FA9  => array(0x1F61, 0x3B9)
  1623.                     ,0x1FAA  => array(0x1F62, 0x3B9)
  1624.                     ,0x1FAB  => array(0x1F63, 0x3B9)
  1625.                     ,0x1FAC  => array(0x1F64, 0x3B9)
  1626.                     ,0x1FAD  => array(0x1F65, 0x3B9)
  1627.                     ,0x1FAE  => array(0x1F66, 0x3B9)
  1628.                     ,0x1FAF  => array(0x1F67, 0x3B9)
  1629.                     ,0x1FB2  => array(0x1F70, 0x3B9)
  1630.                     ,0x1FB3  => array(0x3B1, 0x3B9)
  1631.                     ,0x1FB4  => array(0x3AC, 0x3B9)
  1632.                     ,0x1FB6  => array(0x3B1, 0x342)
  1633.                     ,0x1FB7  => array(0x3B1, 0x342, 0x3B9)
  1634.                     ,0x1FB8  => array(0x1FB0)
  1635.                     ,0x1FB9  => array(0x1FB1)
  1636.                     ,0x1FBA  => array(0x1F70)
  1637.                     ,0x1FBB  => array(0x1F71)
  1638.                     ,0x1FBC  => array(0x3B1, 0x3B9)
  1639.                     ,0x1FBE  => array(0x3B9)
  1640.                     ,0x1FC2  => array(0x1F74, 0x3B9)
  1641.                     ,0x1FC3  => array(0x3B7, 0x3B9)
  1642.                     ,0x1FC4  => array(0x3AE, 0x3B9)
  1643.                     ,0x1FC6  => array(0x3B7, 0x342)
  1644.                     ,0x1FC7  => array(0x3B7, 0x342, 0x3B9)
  1645.                     ,0x1FC8  => array(0x1F72)
  1646.                     ,0x1FC9  => array(0x1F73)
  1647.                     ,0x1FCA  => array(0x1F74)
  1648.                     ,0x1FCB  => array(0x1F75)
  1649.                     ,0x1FCC  => array(0x3B7, 0x3B9)
  1650.                     ,0x1FD2  => array(0x3B9, 0x308, 0x300)
  1651.                     ,0x1FD3  => array(0x3B9, 0x308, 0x301)
  1652.                     ,0x1FD6  => array(0x3B9, 0x342)
  1653.                     ,0x1FD7  => array(0x3B9, 0x308, 0x342)
  1654.                     ,0x1FD8  => array(0x1FD0)
  1655.                     ,0x1FD9  => array(0x1FD1)
  1656.                     ,0x1FDA  => array(0x1F76)
  1657.                     ,0x1FDB  => array(0x1F77)
  1658.                     ,0x1FE2  => array(0x3C5, 0x308, 0x300)
  1659.                     ,0x1FE3  => array(0x3C5, 0x308, 0x301)
  1660.                     ,0x1FE4  => array(0x3C1, 0x313)
  1661.                     ,0x1FE6  => array(0x3C5, 0x342)
  1662.                     ,0x1FE7  => array(0x3C5, 0x308, 0x342)
  1663.                     ,0x1FE8  => array(0x1FE0)
  1664.                     ,0x1FE9  => array(0x1FE1)
  1665.                     ,0x1FEA  => array(0x1F7A)
  1666.                     ,0x1FEB  => array(0x1F7B)
  1667.                     ,0x1FEC  => array(0x1FE5)
  1668.                     ,0x1FF2  => array(0x1F7C, 0x3B9)
  1669.                     ,0x1FF3  => array(0x3C9, 0x3B9)
  1670.                     ,0x1FF4  => array(0x3CE, 0x3B9)
  1671.                     ,0x1FF6  => array(0x3C9, 0x342)
  1672.                     ,0x1FF7  => array(0x3C9, 0x342, 0x3B9)
  1673.                     ,0x1FF8  => array(0x1F78)
  1674.                     ,0x1FF9  => array(0x1F79)
  1675.                     ,0x1FFA  => array(0x1F7C)
  1676.                     ,0x1FFB  => array(0x1F7D)
  1677.                     ,0x1FFC  => array(0x3C9, 0x3B9)
  1678.                     ,0x20A8  => array(0x72, 0x73)
  1679.                     ,0x2102  => array(0x63)
  1680.                     ,0x2103  => array(0xB0, 0x63)
  1681.                     ,0x2107  => array(0x25B)
  1682.                     ,0x2109  => array(0xB0, 0x66)
  1683.                     ,0x210B  => array(0x68)
  1684.                     ,0x210C  => array(0x68)
  1685.                     ,0x210D  => array(0x68)
  1686.                     ,0x2110  => array(0x69)
  1687.                     ,0x2111  => array(0x69)
  1688.                     ,0x2112  => array(0x6C)
  1689.                     ,0x2115  => array(0x6E)
  1690.                     ,0x2116  => array(0x6E, 0x6F)
  1691.                     ,0x2119  => array(0x70)
  1692.                     ,0x211A  => array(0x71)
  1693.                     ,0x211B  => array(0x72)
  1694.                     ,0x211C  => array(0x72)
  1695.                     ,0x211D  => array(0x72)
  1696.                     ,0x2120  => array(0x73, 0x6D)
  1697.                     ,0x2121  => array(0x74, 0x65, 0x6C)
  1698.                     ,0x2122  => array(0x74, 0x6D)
  1699.                     ,0x2124  => array(0x7A)
  1700.                     ,0x2126  => array(0x3C9)
  1701.                     ,0x2128  => array(0x7A)
  1702.                     ,0x212A  => array(0x6B)
  1703.                     ,0x212B  => array(0xE5)
  1704.                     ,0x212C  => array(0x62)
  1705.                     ,0x212D  => array(0x63)
  1706.                     ,0x2130  => array(0x65)
  1707.                     ,0x2131  => array(0x66)
  1708.                     ,0x2133  => array(0x6D)
  1709.                     ,0x213E  => array(0x3B3)
  1710.                     ,0x213F  => array(0x3C0)
  1711.                     ,0x2145  => array(0x64)
  1712.                     ,0x2160  => array(0x2170)
  1713.                     ,0x2161  => array(0x2171)
  1714.                     ,0x2162  => array(0x2172)
  1715.                     ,0x2163  => array(0x2173)
  1716.                     ,0x2164  => array(0x2174)
  1717.                     ,0x2165  => array(0x2175)
  1718.                     ,0x2166  => array(0x2176)
  1719.                     ,0x2167  => array(0x2177)
  1720.                     ,0x2168  => array(0x2178)
  1721.                     ,0x2169  => array(0x2179)
  1722.                     ,0x216A  => array(0x217A)
  1723.                     ,0x216B  => array(0x217B)
  1724.                     ,0x216C  => array(0x217C)
  1725.                     ,0x216D  => array(0x217D)
  1726.                     ,0x216E  => array(0x217E)
  1727.                     ,0x216F  => array(0x217F)
  1728.                     ,0x24B6  => array(0x24D0)
  1729.                     ,0x24B7  => array(0x24D1)
  1730.                     ,0x24B8  => array(0x24D2)
  1731.                     ,0x24B9  => array(0x24D3)
  1732.                     ,0x24BA  => array(0x24D4)
  1733.                     ,0x24BB  => array(0x24D5)
  1734.                     ,0x24BC  => array(0x24D6)
  1735.                     ,0x24BD  => array(0x24D7)
  1736.                     ,0x24BE  => array(0x24D8)
  1737.                     ,0x24BF  => array(0x24D9)
  1738.                     ,0x24C0  => array(0x24DA)
  1739.                     ,0x24C1  => array(0x24DB)
  1740.                     ,0x24C2  => array(0x24DC)
  1741.                     ,0x24C3  => array(0x24DD)
  1742.                     ,0x24C4  => array(0x24DE)
  1743.                     ,0x24C5  => array(0x24DF)
  1744.                     ,0x24C6  => array(0x24E0)
  1745.                     ,0x24C7  => array(0x24E1)
  1746.                     ,0x24C8  => array(0x24E2)
  1747.                     ,0x24C9  => array(0x24E3)
  1748.                     ,0x24CA  => array(0x24E4)
  1749.                     ,0x24CB  => array(0x24E5)
  1750.                     ,0x24CC  => array(0x24E6)
  1751.                     ,0x24CD  => array(0x24E7)
  1752.                     ,0x24CE  => array(0x24E8)
  1753.                     ,0x24CF  => array(0x24E9)
  1754.                     ,0x3371  => array(0x68, 0x70, 0x61)
  1755.                     ,0x3373  => array(0x61, 0x75)
  1756.                     ,0x3375  => array(0x6F, 0x76)
  1757.                     ,0x3380  => array(0x70, 0x61)
  1758.                     ,0x3381  => array(0x6E, 0x61)
  1759.                     ,0x3382  => array(0x3BC, 0x61)
  1760.                     ,0x3383  => array(0x6D, 0x61)
  1761.                     ,0x3384  => array(0x6B, 0x61)
  1762.                     ,0x3385  => array(0x6B, 0x62)
  1763.                     ,0x3386  => array(0x6D, 0x62)
  1764.                     ,0x3387  => array(0x67, 0x62)
  1765.                     ,0x338A  => array(0x70, 0x66)
  1766.                     ,0x338B  => array(0x6E, 0x66)
  1767.                     ,0x338C  => array(0x3BC, 0x66)
  1768.                     ,0x3390  => array(0x68, 0x7A)
  1769.                     ,0x3391  => array(0x6B, 0x68, 0x7A)
  1770.                     ,0x3392  => array(0x6D, 0x68, 0x7A)
  1771.                     ,0x3393  => array(0x67, 0x68, 0x7A)
  1772.                     ,0x3394  => array(0x74, 0x68, 0x7A)
  1773.                     ,0x33A9  => array(0x70, 0x61)
  1774.                     ,0x33AA  => array(0x6B, 0x70, 0x61)
  1775.                     ,0x33AB  => array(0x6D, 0x70, 0x61)
  1776.                     ,0x33AC  => array(0x67, 0x70, 0x61)
  1777.                     ,0x33B4  => array(0x70, 0x76)
  1778.                     ,0x33B5  => array(0x6E, 0x76)
  1779.                     ,0x33B6  => array(0x3BC, 0x76)
  1780.                     ,0x33B7  => array(0x6D, 0x76)
  1781.                     ,0x33B8  => array(0x6B, 0x76)
  1782.                     ,0x33B9  => array(0x6D, 0x76)
  1783.                     ,0x33BA  => array(0x70, 0x77)
  1784.                     ,0x33BB  => array(0x6E, 0x77)
  1785.                     ,0x33BC  => array(0x3BC, 0x77)
  1786.                     ,0x33BD  => array(0x6D, 0x77)
  1787.                     ,0x33BE  => array(0x6B, 0x77)
  1788.                     ,0x33BF  => array(0x6D, 0x77)
  1789.                     ,0x33C0  => array(0x6B, 0x3C9)
  1790.                     ,0x33C1  => array(0x6D, 0x3C9) /*
  1791.                     ,0x33C2  => array(0x61, 0x2E, 0x6D, 0x2E) */
  1792.                     ,0x33C3  => array(0x62, 0x71)
  1793.                     ,0x33C6  => array(0x63, 0x2215, 0x6B, 0x67)
  1794.                     ,0x33C7  => array(0x63, 0x6F, 0x2E)
  1795.                     ,0x33C8  => array(0x64, 0x62)
  1796.                     ,0x33C9  => array(0x67, 0x79)
  1797.                     ,0x33CB  => array(0x68, 0x70)
  1798.                     ,0x33CD  => array(0x6B, 0x6B)
  1799.                     ,0x33CE  => array(0x6B, 0x6D)
  1800.                     ,0x33D7  => array(0x70, 0x68)
  1801.                     ,0x33D9  => array(0x70, 0x70, 0x6D)
  1802.                     ,0x33DA  => array(0x70, 0x72)
  1803.                     ,0x33DC  => array(0x73, 0x76)
  1804.                     ,0x33DD  => array(0x77, 0x62)
  1805.                     ,0xFB00  => array(0x66, 0x66)
  1806.                     ,0xFB01  => array(0x66, 0x69)
  1807.                     ,0xFB02  => array(0x66, 0x6C)
  1808.                     ,0xFB03  => array(0x66, 0x66, 0x69)
  1809.                     ,0xFB04  => array(0x66, 0x66, 0x6C)
  1810.                     ,0xFB05  => array(0x73, 0x74)
  1811.                     ,0xFB06  => array(0x73, 0x74)
  1812.                     ,0xFB13  => array(0x574, 0x576)
  1813.                     ,0xFB14  => array(0x574, 0x565)
  1814.                     ,0xFB15  => array(0x574, 0x56B)
  1815.                     ,0xFB16  => array(0x57E, 0x576)
  1816.                     ,0xFB17  => array(0x574, 0x56D)
  1817.                     ,0xFF21  => array(0xFF41)
  1818.                     ,0xFF22  => array(0xFF42)
  1819.                     ,0xFF23  => array(0xFF43)
  1820.                     ,0xFF24  => array(0xFF44)
  1821.                     ,0xFF25  => array(0xFF45)
  1822.                     ,0xFF26  => array(0xFF46)
  1823.                     ,0xFF27  => array(0xFF47)
  1824.                     ,0xFF28  => array(0xFF48)
  1825.                     ,0xFF29  => array(0xFF49)
  1826.                     ,0xFF2A  => array(0xFF4A)
  1827.                     ,0xFF2B  => array(0xFF4B)
  1828.                     ,0xFF2C  => array(0xFF4C)
  1829.                     ,0xFF2D  => array(0xFF4D)
  1830.                     ,0xFF2E  => array(0xFF4E)
  1831.                     ,0xFF2F  => array(0xFF4F)
  1832.                     ,0xFF30  => array(0xFF50)
  1833.                     ,0xFF31  => array(0xFF51)
  1834.                     ,0xFF32  => array(0xFF52)
  1835.                     ,0xFF33  => array(0xFF53)
  1836.                     ,0xFF34  => array(0xFF54)
  1837.                     ,0xFF35  => array(0xFF55)
  1838.                     ,0xFF36  => array(0xFF56)
  1839.                     ,0xFF37  => array(0xFF57)
  1840.                     ,0xFF38  => array(0xFF58)
  1841.                     ,0xFF39  => array(0xFF59)
  1842.                     ,0xFF3A  => array(0xFF5A)
  1843.                     ,0x10400 => array(0x10428)
  1844.                     ,0x10401 => array(0x10429)
  1845.                     ,0x10402 => array(0x1042A)
  1846.                     ,0x10403 => array(0x1042B)
  1847.                     ,0x10404 => array(0x1042C)
  1848.                     ,0x10405 => array(0x1042D)
  1849.                     ,0x10406 => array(0x1042E)
  1850.                     ,0x10407 => array(0x1042F)
  1851.                     ,0x10408 => array(0x10430)
  1852.                     ,0x10409 => array(0x10431)
  1853.                     ,0x1040A => array(0x10432)
  1854.                     ,0x1040B => array(0x10433)
  1855.                     ,0x1040C => array(0x10434)
  1856.                     ,0x1040D => array(0x10435)
  1857.                     ,0x1040E => array(0x10436)
  1858.                     ,0x1040F => array(0x10437)
  1859.                     ,0x10410 => array(0x10438)
  1860.                     ,0x10411 => array(0x10439)
  1861.                     ,0x10412 => array(0x1043A)
  1862.                     ,0x10413 => array(0x1043B)
  1863.                     ,0x10414 => array(0x1043C)
  1864.                     ,0x10415 => array(0x1043D)
  1865.                     ,0x10416 => array(0x1043E)
  1866.                     ,0x10417 => array(0x1043F)
  1867.                     ,0x10418 => array(0x10440)
  1868.                     ,0x10419 => array(0x10441)
  1869.                     ,0x1041A => array(0x10442)
  1870.                     ,0x1041B => array(0x10443)
  1871.                     ,0x1041C => array(0x10444)
  1872.                     ,0x1041D => array(0x10445)
  1873.                     ,0x1041E => array(0x10446)
  1874.                     ,0x1041F => array(0x10447)
  1875.                     ,0x10420 => array(0x10448)
  1876.                     ,0x10421 => array(0x10449)
  1877.                     ,0x10422 => array(0x1044A)
  1878.                     ,0x10423 => array(0x1044B)
  1879.                     ,0x10424 => array(0x1044C)
  1880.                     ,0x10425 => array(0x1044D)
  1881.                     ,0x1D400 => array(0x61)
  1882.                     ,0x1D401 => array(0x62)
  1883.                     ,0x1D402 => array(0x63)
  1884.                     ,0x1D403 => array(0x64)
  1885.                     ,0x1D404 => array(0x65)
  1886.                     ,0x1D405 => array(0x66)
  1887.                     ,0x1D406 => array(0x67)
  1888.                     ,0x1D407 => array(0x68)
  1889.                     ,0x1D408 => array(0x69)
  1890.                     ,0x1D409 => array(0x6A)
  1891.                     ,0x1D40A => array(0x6B)
  1892.                     ,0x1D40B => array(0x6C)
  1893.                     ,0x1D40C => array(0x6D)
  1894.                     ,0x1D40D => array(0x6E)
  1895.                     ,0x1D40E => array(0x6F)
  1896.                     ,0x1D40F => array(0x70)
  1897.                     ,0x1D410 => array(0x71)
  1898.                     ,0x1D411 => array(0x72)
  1899.                     ,0x1D412 => array(0x73)
  1900.                     ,0x1D413 => array(0x74)
  1901.                     ,0x1D414 => array(0x75)
  1902.                     ,0x1D415 => array(0x76)
  1903.                     ,0x1D416 => array(0x77)
  1904.                     ,0x1D417 => array(0x78)
  1905.                     ,0x1D418 => array(0x79)
  1906.                     ,0x1D419 => array(0x7A)
  1907.                     ,0x1D434 => array(0x61)
  1908.                     ,0x1D435 => array(0x62)
  1909.                     ,0x1D436 => array(0x63)
  1910.                     ,0x1D437 => array(0x64)
  1911.                     ,0x1D438 => array(0x65)
  1912.                     ,0x1D439 => array(0x66)
  1913.                     ,0x1D43A => array(0x67)
  1914.                     ,0x1D43B => array(0x68)
  1915.                     ,0x1D43C => array(0x69)
  1916.                     ,0x1D43D => array(0x6A)
  1917.                     ,0x1D43E => array(0x6B)
  1918.                     ,0x1D43F => array(0x6C)
  1919.                     ,0x1D440 => array(0x6D)
  1920.                     ,0x1D441 => array(0x6E)
  1921.                     ,0x1D442 => array(0x6F)
  1922.                     ,0x1D443 => array(0x70)
  1923.                     ,0x1D444 => array(0x71)
  1924.                     ,0x1D445 => array(0x72)
  1925.                     ,0x1D446 => array(0x73)
  1926.                     ,0x1D447 => array(0x74)
  1927.                     ,0x1D448 => array(0x75)
  1928.                     ,0x1D449 => array(0x76)
  1929.                     ,0x1D44A => array(0x77)
  1930.                     ,0x1D44B => array(0x78)
  1931.                     ,0x1D44C => array(0x79)
  1932.                     ,0x1D44D => array(0x7A)
  1933.                     ,0x1D468 => array(0x61)
  1934.                     ,0x1D469 => array(0x62)
  1935.                     ,0x1D46A => array(0x63)
  1936.                     ,0x1D46B => array(0x64)
  1937.                     ,0x1D46C => array(0x65)
  1938.                     ,0x1D46D => array(0x66)
  1939.                     ,0x1D46E => array(0x67)
  1940.                     ,0x1D46F => array(0x68)
  1941.                     ,0x1D470 => array(0x69)
  1942.                     ,0x1D471 => array(0x6A)
  1943.                     ,0x1D472 => array(0x6B)
  1944.                     ,0x1D473 => array(0x6C)
  1945.                     ,0x1D474 => array(0x6D)
  1946.                     ,0x1D475 => array(0x6E)
  1947.                     ,0x1D476 => array(0x6F)
  1948.                     ,0x1D477 => array(0x70)
  1949.                     ,0x1D478 => array(0x71)
  1950.                     ,0x1D479 => array(0x72)
  1951.                     ,0x1D47A => array(0x73)
  1952.                     ,0x1D47B => array(0x74)
  1953.                     ,0x1D47C => array(0x75)
  1954.                     ,0x1D47D => array(0x76)
  1955.                     ,0x1D47E => array(0x77)
  1956.                     ,0x1D47F => array(0x78)
  1957.                     ,0x1D480 => array(0x79)
  1958.                     ,0x1D481 => array(0x7A)
  1959.                     ,0x1D49C => array(0x61)
  1960.                     ,0x1D49E => array(0x63)
  1961.                     ,0x1D49F => array(0x64)
  1962.                     ,0x1D4A2 => array(0x67)
  1963.                     ,0x1D4A5 => array(0x6A)
  1964.                     ,0x1D4A6 => array(0x6B)
  1965.                     ,0x1D4A9 => array(0x6E)
  1966.                     ,0x1D4AA => array(0x6F)
  1967.                     ,0x1D4AB => array(0x70)
  1968.                     ,0x1D4AC => array(0x71)
  1969.                     ,0x1D4AE => array(0x73)
  1970.                     ,0x1D4AF => array(0x74)
  1971.                     ,0x1D4B0 => array(0x75)
  1972.                     ,0x1D4B1 => array(0x76)
  1973.                     ,0x1D4B2 => array(0x77)
  1974.                     ,0x1D4B3 => array(0x78)
  1975.                     ,0x1D4B4 => array(0x79)
  1976.                     ,0x1D4B5 => array(0x7A)
  1977.                     ,0x1D4D0 => array(0x61)
  1978.                     ,0x1D4D1 => array(0x62)
  1979.                     ,0x1D4D2 => array(0x63)
  1980.                     ,0x1D4D3 => array(0x64)
  1981.                     ,0x1D4D4 => array(0x65)
  1982.                     ,0x1D4D5 => array(0x66)
  1983.                     ,0x1D4D6 => array(0x67)
  1984.                     ,0x1D4D7 => array(0x68)
  1985.                     ,0x1D4D8 => array(0x69)
  1986.                     ,0x1D4D9 => array(0x6A)
  1987.                     ,0x1D4DA => array(0x6B)
  1988.                     ,0x1D4DB => array(0x6C)
  1989.                     ,0x1D4DC => array(0x6D)
  1990.                     ,0x1D4DD => array(0x6E)
  1991.                     ,0x1D4DE => array(0x6F)
  1992.                     ,0x1D4DF => array(0x70)
  1993.                     ,0x1D4E0 => array(0x71)
  1994.                     ,0x1D4E1 => array(0x72)
  1995.                     ,0x1D4E2 => array(0x73)
  1996.                     ,0x1D4E3 => array(0x74)
  1997.                     ,0x1D4E4 => array(0x75)
  1998.                     ,0x1D4E5 => array(0x76)
  1999.                     ,0x1D4E6 => array(0x77)
  2000.                     ,0x1D4E7 => array(0x78)
  2001.                     ,0x1D4E8 => array(0x79)
  2002.                     ,0x1D4E9 => array(0x7A)
  2003.                     ,0x1D504 => array(0x61)
  2004.                     ,0x1D505 => array(0x62)
  2005.                     ,0x1D507 => array(0x64)
  2006.                     ,0x1D508 => array(0x65)
  2007.                     ,0x1D509 => array(0x66)
  2008.                     ,0x1D50A => array(0x67)
  2009.                     ,0x1D50D => array(0x6A)
  2010.                     ,0x1D50E => array(0x6B)
  2011.                     ,0x1D50F => array(0x6C)
  2012.                     ,0x1D510 => array(0x6D)
  2013.                     ,0x1D511 => array(0x6E)
  2014.                     ,0x1D512 => array(0x6F)
  2015.                     ,0x1D513 => array(0x70)
  2016.                     ,0x1D514 => array(0x71)
  2017.                     ,0x1D516 => array(0x73)
  2018.                     ,0x1D517 => array(0x74)
  2019.                     ,0x1D518 => array(0x75)
  2020.                     ,0x1D519 => array(0x76)
  2021.                     ,0x1D51A => array(0x77)
  2022.                     ,0x1D51B => array(0x78)
  2023.                     ,0x1D51C => array(0x79)
  2024.                     ,0x1D538 => array(0x61)
  2025.                     ,0x1D539 => array(0x62)
  2026.                     ,0x1D53B => array(0x64)
  2027.                     ,0x1D53C => array(0x65)
  2028.                     ,0x1D53D => array(0x66)
  2029.                     ,0x1D53E => array(0x67)
  2030.                     ,0x1D540 => array(0x69)
  2031.                     ,0x1D541 => array(0x6A)
  2032.                     ,0x1D542 => array(0x6B)
  2033.                     ,0x1D543 => array(0x6C)
  2034.                     ,0x1D544 => array(0x6D)
  2035.                     ,0x1D546 => array(0x6F)
  2036.                     ,0x1D54A => array(0x73)
  2037.                     ,0x1D54B => array(0x74)
  2038.                     ,0x1D54C => array(0x75)
  2039.                     ,0x1D54D => array(0x76)
  2040.                     ,0x1D54E => array(0x77)
  2041.                     ,0x1D54F => array(0x78)
  2042.                     ,0x1D550 => array(0x79)
  2043.                     ,0x1D56C => array(0x61)
  2044.                     ,0x1D56D => array(0x62)
  2045.                     ,0x1D56E => array(0x63)
  2046.                     ,0x1D56F => array(0x64)
  2047.                     ,0x1D570 => array(0x65)
  2048.                     ,0x1D571 => array(0x66)
  2049.                     ,0x1D572 => array(0x67)
  2050.                     ,0x1D573 => array(0x68)
  2051.                     ,0x1D574 => array(0x69)
  2052.                     ,0x1D575 => array(0x6A)
  2053.                     ,0x1D576 => array(0x6B)
  2054.                     ,0x1D577 => array(0x6C)
  2055.                     ,0x1D578 => array(0x6D)
  2056.                     ,0x1D579 => array(0x6E)
  2057.                     ,0x1D57A => array(0x6F)
  2058.                     ,0x1D57B => array(0x70)
  2059.                     ,0x1D57C => array(0x71)
  2060.                     ,0x1D57D => array(0x72)
  2061.                     ,0x1D57E => array(0x73)
  2062.                     ,0x1D57F => array(0x74)
  2063.                     ,0x1D580 => array(0x75)
  2064.                     ,0x1D581 => array(0x76)
  2065.                     ,0x1D582 => array(0x77)
  2066.                     ,0x1D583 => array(0x78)
  2067.                     ,0x1D584 => array(0x79)
  2068.                     ,0x1D585 => array(0x7A)
  2069.                     ,0x1D5A0 => array(0x61)
  2070.                     ,0x1D5A1 => array(0x62)
  2071.                     ,0x1D5A2 => array(0x63)
  2072.                     ,0x1D5A3 => array(0x64)
  2073.                     ,0x1D5A4 => array(0x65)
  2074.                     ,0x1D5A5 => array(0x66)
  2075.                     ,0x1D5A6 => array(0x67)
  2076.                     ,0x1D5A7 => array(0x68)
  2077.                     ,0x1D5A8 => array(0x69)
  2078.                     ,0x1D5A9 => array(0x6A)
  2079.                     ,0x1D5AA => array(0x6B)
  2080.                     ,0x1D5AB => array(0x6C)
  2081.                     ,0x1D5AC => array(0x6D)
  2082.                     ,0x1D5AD => array(0x6E)
  2083.                     ,0x1D5AE => array(0x6F)
  2084.                     ,0x1D5AF => array(0x70)
  2085.                     ,0x1D5B0 => array(0x71)
  2086.                     ,0x1D5B1 => array(0x72)
  2087.                     ,0x1D5B2 => array(0x73)
  2088.                     ,0x1D5B3 => array(0x74)
  2089.                     ,0x1D5B4 => array(0x75)
  2090.                     ,0x1D5B5 => array(0x76)
  2091.                     ,0x1D5B6 => array(0x77)
  2092.                     ,0x1D5B7 => array(0x78)
  2093.                     ,0x1D5B8 => array(0x79)
  2094.                     ,0x1D5B9 => array(0x7A)
  2095.                     ,0x1D5D4 => array(0x61)
  2096.                     ,0x1D5D5 => array(0x62)
  2097.                     ,0x1D5D6 => array(0x63)
  2098.                     ,0x1D5D7 => array(0x64)
  2099.                     ,0x1D5D8 => array(0x65)
  2100.                     ,0x1D5D9 => array(0x66)
  2101.                     ,0x1D5DA => array(0x67)
  2102.                     ,0x1D5DB => array(0x68)
  2103.                     ,0x1D5DC => array(0x69)
  2104.                     ,0x1D5DD => array(0x6A)
  2105.                     ,0x1D5DE => array(0x6B)
  2106.                     ,0x1D5DF => array(0x6C)
  2107.                     ,0x1D5E0 => array(0x6D)
  2108.                     ,0x1D5E1 => array(0x6E)
  2109.                     ,0x1D5E2 => array(0x6F)
  2110.                     ,0x1D5E3 => array(0x70)
  2111.                     ,0x1D5E4 => array(0x71)
  2112.                     ,0x1D5E5 => array(0x72)
  2113.                     ,0x1D5E6 => array(0x73)
  2114.                     ,0x1D5E7 => array(0x74)
  2115.                     ,0x1D5E8 => array(0x75)
  2116.                     ,0x1D5E9 => array(0x76)
  2117.                     ,0x1D5EA => array(0x77)
  2118.                     ,0x1D5EB => array(0x78)
  2119.                     ,0x1D5EC => array(0x79)
  2120.                     ,0x1D5ED => array(0x7A)
  2121.                     ,0x1D608 => array(0x61)
  2122.                     ,0x1D609 => array(0x62)
  2123.                     ,0x1D60A => array(0x63)
  2124.                     ,0x1D60B => array(0x64)
  2125.                     ,0x1D60C => array(0x65)
  2126.                     ,0x1D60D => array(0x66)
  2127.                     ,0x1D60E => array(0x67)
  2128.                     ,0x1D60F => array(0x68)
  2129.                     ,0x1D610 => array(0x69)
  2130.                     ,0x1D611 => array(0x6A)
  2131.                     ,0x1D612 => array(0x6B)
  2132.                     ,0x1D613 => array(0x6C)
  2133.                     ,0x1D614 => array(0x6D)
  2134.                     ,0x1D615 => array(0x6E)
  2135.                     ,0x1D616 => array(0x6F)
  2136.                     ,0x1D617 => array(0x70)
  2137.                     ,0x1D618 => array(0x71)
  2138.                     ,0x1D619 => array(0x72)
  2139.                     ,0x1D61A => array(0x73)
  2140.                     ,0x1D61B => array(0x74)
  2141.                     ,0x1D61C => array(0x75)
  2142.                     ,0x1D61D => array(0x76)
  2143.                     ,0x1D61E => array(0x77)
  2144.                     ,0x1D61F => array(0x78)
  2145.                     ,0x1D620 => array(0x79)
  2146.                     ,0x1D621 => array(0x7A)
  2147.                     ,0x1D63C => array(0x61)
  2148.                     ,0x1D63D => array(0x62)
  2149.                     ,0x1D63E => array(0x63)
  2150.                     ,0x1D63F => array(0x64)
  2151.                     ,0x1D640 => array(0x65)
  2152.                     ,0x1D641 => array(0x66)
  2153.                     ,0x1D642 => array(0x67)
  2154.                     ,0x1D643 => array(0x68)
  2155.                     ,0x1D644 => array(0x69)
  2156.                     ,0x1D645 => array(0x6A)
  2157.                     ,0x1D646 => array(0x6B)
  2158.                     ,0x1D647 => array(0x6C)
  2159.                     ,0x1D648 => array(0x6D)
  2160.                     ,0x1D649 => array(0x6E)
  2161.                     ,0x1D64A => array(0x6F)
  2162.                     ,0x1D64B => array(0x70)
  2163.                     ,0x1D64C => array(0x71)
  2164.                     ,0x1D64D => array(0x72)
  2165.                     ,0x1D64E => array(0x73)
  2166.                     ,0x1D64F => array(0x74)
  2167.                     ,0x1D650 => array(0x75)
  2168.                     ,0x1D651 => array(0x76)
  2169.                     ,0x1D652 => array(0x77)
  2170.                     ,0x1D653 => array(0x78)
  2171.                     ,0x1D654 => array(0x79)
  2172.                     ,0x1D655 => array(0x7A)
  2173.                     ,0x1D670 => array(0x61)
  2174.                     ,0x1D671 => array(0x62)
  2175.                     ,0x1D672 => array(0x63)
  2176.                     ,0x1D673 => array(0x64)
  2177.                     ,0x1D674 => array(0x65)
  2178.                     ,0x1D675 => array(0x66)
  2179.                     ,0x1D676 => array(0x67)
  2180.                     ,0x1D677 => array(0x68)
  2181.                     ,0x1D678 => array(0x69)
  2182.                     ,0x1D679 => array(0x6A)
  2183.                     ,0x1D67A => array(0x6B)
  2184.                     ,0x1D67B => array(0x6C)
  2185.                     ,0x1D67C => array(0x6D)
  2186.                     ,0x1D67D => array(0x6E)
  2187.                     ,0x1D67E => array(0x6F)
  2188.                     ,0x1D67F => array(0x70)
  2189.                     ,0x1D680 => array(0x71)
  2190.                     ,0x1D681 => array(0x72)
  2191.                     ,0x1D682 => array(0x73)
  2192.                     ,0x1D683 => array(0x74)
  2193.                     ,0x1D684 => array(0x75)
  2194.                     ,0x1D685 => array(0x76)
  2195.                     ,0x1D686 => array(0x77)
  2196.                     ,0x1D687 => array(0x78)
  2197.                     ,0x1D688 => array(0x79)
  2198.                     ,0x1D689 => array(0x7A)
  2199.                     ,0x1D6A8 => array(0x3B1)
  2200.                     ,0x1D6A9 => array(0x3B2)
  2201.                     ,0x1D6AA => array(0x3B3)
  2202.                     ,0x1D6AB => array(0x3B4)
  2203.                     ,0x1D6AC => array(0x3B5)
  2204.                     ,0x1D6AD => array(0x3B6)
  2205.                     ,0x1D6AE => array(0x3B7)
  2206.                     ,0x1D6AF => array(0x3B8)
  2207.                     ,0x1D6B0 => array(0x3B9)
  2208.                     ,0x1D6B1 => array(0x3BA)
  2209.                     ,0x1D6B2 => array(0x3BB)
  2210.                     ,0x1D6B3 => array(0x3BC)
  2211.                     ,0x1D6B4 => array(0x3BD)
  2212.                     ,0x1D6B5 => array(0x3BE)
  2213.                     ,0x1D6B6 => array(0x3BF)
  2214.                     ,0x1D6B7 => array(0x3C0)
  2215.                     ,0x1D6B8 => array(0x3C1)
  2216.                     ,0x1D6B9 => array(0x3B8)
  2217.                     ,0x1D6BA => array(0x3C3)
  2218.                     ,0x1D6BB => array(0x3C4)
  2219.                     ,0x1D6BC => array(0x3C5)
  2220.                     ,0x1D6BD => array(0x3C6)
  2221.                     ,0x1D6BE => array(0x3C7)
  2222.                     ,0x1D6BF => array(0x3C8)
  2223.                     ,0x1D6C0 => array(0x3C9)
  2224.                     ,0x1D6D3 => array(0x3C3)
  2225.                     ,0x1D6E2 => array(0x3B1)
  2226.                     ,0x1D6E3 => array(0x3B2)
  2227.                     ,0x1D6E4 => array(0x3B3)
  2228.                     ,0x1D6E5 => array(0x3B4)
  2229.                     ,0x1D6E6 => array(0x3B5)
  2230.                     ,0x1D6E7 => array(0x3B6)
  2231.                     ,0x1D6E8 => array(0x3B7)
  2232.                     ,0x1D6E9 => array(0x3B8)
  2233.                     ,0x1D6EA => array(0x3B9)
  2234.                     ,0x1D6EB => array(0x3BA)
  2235.                     ,0x1D6EC => array(0x3BB)
  2236.                     ,0x1D6ED => array(0x3BC)
  2237.                     ,0x1D6EE => array(0x3BD)
  2238.                     ,0x1D6EF => array(0x3BE)
  2239.                     ,0x1D6F0 => array(0x3BF)
  2240.                     ,0x1D6F1 => array(0x3C0)
  2241.                     ,0x1D6F2 => array(0x3C1)
  2242.                     ,0x1D6F3 => array(0x3B8)
  2243.                     ,0x1D6F4 => array(0x3C3)
  2244.                     ,0x1D6F5 => array(0x3C4)
  2245.                     ,0x1D6F6 => array(0x3C5)
  2246.                     ,0x1D6F7 => array(0x3C6)
  2247.                     ,0x1D6F8 => array(0x3C7)
  2248.                     ,0x1D6F9 => array(0x3C8)
  2249.                     ,0x1D6FA => array(0x3C9)
  2250.                     ,0x1D70D => array(0x3C3)
  2251.                     ,0x1D71C => array(0x3B1)
  2252.                     ,0x1D71D => array(0x3B2)
  2253.                     ,0x1D71E => array(0x3B3)
  2254.                     ,0x1D71F => array(0x3B4)
  2255.                     ,0x1D720 => array(0x3B5)
  2256.                     ,0x1D721 => array(0x3B6)
  2257.                     ,0x1D722 => array(0x3B7)
  2258.                     ,0x1D723 => array(0x3B8)
  2259.                     ,0x1D724 => array(0x3B9)
  2260.                     ,0x1D725 => array(0x3BA)
  2261.                     ,0x1D726 => array(0x3BB)
  2262.                     ,0x1D727 => array(0x3BC)
  2263.                     ,0x1D728 => array(0x3BD)
  2264.                     ,0x1D729 => array(0x3BE)
  2265.                     ,0x1D72A => array(0x3BF)
  2266.                     ,0x1D72B => array(0x3C0)
  2267.                     ,0x1D72C => array(0x3C1)
  2268.                     ,0x1D72D => array(0x3B8)
  2269.                     ,0x1D72E => array(0x3C3)
  2270.                     ,0x1D72F => array(0x3C4)
  2271.                     ,0x1D730 => array(0x3C5)
  2272.                     ,0x1D731 => array(0x3C6)
  2273.                     ,0x1D732 => array(0x3C7)
  2274.                     ,0x1D733 => array(0x3C8)
  2275.                     ,0x1D734 => array(0x3C9)
  2276.                     ,0x1D747 => array(0x3C3)
  2277.                     ,0x1D756 => array(0x3B1)
  2278.                     ,0x1D757 => array(0x3B2)
  2279.                     ,0x1D758 => array(0x3B3)
  2280.                     ,0x1D759 => array(0x3B4)
  2281.                     ,0x1D75A => array(0x3B5)
  2282.                     ,0x1D75B => array(0x3B6)
  2283.                     ,0x1D75C => array(0x3B7)
  2284.                     ,0x1D75D => array(0x3B8)
  2285.                     ,0x1D75E => array(0x3B9)
  2286.                     ,0x1D75F => array(0x3BA)
  2287.                     ,0x1D760 => array(0x3BB)
  2288.                     ,0x1D761 => array(0x3BC)
  2289.                     ,0x1D762 => array(0x3BD)
  2290.                     ,0x1D763 => array(0x3BE)
  2291.                     ,0x1D764 => array(0x3BF)
  2292.                     ,0x1D765 => array(0x3C0)
  2293.                     ,0x1D766 => array(0x3C1)
  2294.                     ,0x1D767 => array(0x3B8)
  2295.                     ,0x1D768 => array(0x3C3)
  2296.                     ,0x1D769 => array(0x3C4)
  2297.                     ,0x1D76A => array(0x3C5)
  2298.                     ,0x1D76B => array(0x3C6)
  2299.                     ,0x1D76C => array(0x3C7)
  2300.                     ,0x1D76D => array(0x3C8)
  2301.                     ,0x1D76E => array(0x3C9)
  2302.                     ,0x1D781 => array(0x3C3)
  2303.                     ,0x1D790 => array(0x3B1)
  2304.                     ,0x1D791 => array(0x3B2)
  2305.                     ,0x1D792 => array(0x3B3)
  2306.                     ,0x1D793 => array(0x3B4)
  2307.                     ,0x1D794 => array(0x3B5)
  2308.                     ,0x1D795 => array(0x3B6)
  2309.                     ,0x1D796 => array(0x3B7)
  2310.                     ,0x1D797 => array(0x3B8)
  2311.                     ,0x1D798 => array(0x3B9)
  2312.                     ,0x1D799 => array(0x3BA)
  2313.                     ,0x1D79A => array(0x3BB)
  2314.                     ,0x1D79B => array(0x3BC)
  2315.                     ,0x1D79C => array(0x3BD)
  2316.                     ,0x1D79D => array(0x3BE)
  2317.                     ,0x1D79E => array(0x3BF)
  2318.                     ,0x1D79F => array(0x3C0)
  2319.                     ,0x1D7A0 => array(0x3C1)
  2320.                     ,0x1D7A1 => array(0x3B8)
  2321.                     ,0x1D7A2 => array(0x3C3)
  2322.                     ,0x1D7A3 => array(0x3C4)
  2323.                     ,0x1D7A4 => array(0x3C5)
  2324.                     ,0x1D7A5 => array(0x3C6)
  2325.                     ,0x1D7A6 => array(0x3C7)
  2326.                     ,0x1D7A7 => array(0x3C8)
  2327.                     ,0x1D7A8 => array(0x3C9)
  2328.                     ,0x1D7BB => array(0x3C3)
  2329.                     ,0x3F9   => array(0x3C3)
  2330.                     ,0x1D2C  => array(0x61)
  2331.                     ,0x1D2D  => array(0xE6)
  2332.                     ,0x1D2E  => array(0x62)
  2333.                     ,0x1D30  => array(0x64)
  2334.                     ,0x1D31  => array(0x65)
  2335.                     ,0x1D32  => array(0x1DD)
  2336.                     ,0x1D33  => array(0x67)
  2337.                     ,0x1D34  => array(0x68)
  2338.                     ,0x1D35  => array(0x69)
  2339.                     ,0x1D36  => array(0x6A)
  2340.                     ,0x1D37  => array(0x6B)
  2341.                     ,0x1D38  => array(0x6C)
  2342.                     ,0x1D39  => array(0x6D)
  2343.                     ,0x1D3A  => array(0x6E)
  2344.                     ,0x1D3C  => array(0x6F)
  2345.                     ,0x1D3D  => array(0x223)
  2346.                     ,0x1D3E  => array(0x70)
  2347.                     ,0x1D3F  => array(0x72)
  2348.                     ,0x1D40  => array(0x74)
  2349.                     ,0x1D41  => array(0x75)
  2350.                     ,0x1D42  => array(0x77)
  2351.                     ,0x213B  => array(0x66, 0x61, 0x78)
  2352.                     ,0x3250  => array(0x70, 0x74, 0x65)
  2353.                     ,0x32CC  => array(0x68, 0x67)
  2354.                     ,0x32CE  => array(0x65, 0x76)
  2355.                     ,0x32CF  => array(0x6C, 0x74, 0x64)
  2356.                     ,0x337A  => array(0x69, 0x75)
  2357.                     ,0x33DE  => array(0x76, 0x2215, 0x6D)
  2358.                     ,0x33DF  => array(0x61, 0x2215, 0x6D)
  2359.                     )
  2360.             ,'norm_combcls' => array
  2361.                     (0x334   => 1
  2362.                     ,0x335   => 1
  2363.                     ,0x336   => 1
  2364.                     ,0x337   => 1
  2365.                     ,0x338   => 1
  2366.                     ,0x93C   => 7
  2367.                     ,0x9BC   => 7
  2368.                     ,0xA3C   => 7
  2369.                     ,0xABC   => 7
  2370.                     ,0xB3C   => 7
  2371.                     ,0xCBC   => 7
  2372.                     ,0x1037  => 7
  2373.                     ,0x3099  => 8
  2374.                     ,0x309A  => 8
  2375.                     ,0x94D   => 9
  2376.                     ,0x9CD   => 9
  2377.                     ,0xA4D   => 9
  2378.                     ,0xACD   => 9
  2379.                     ,0xB4D   => 9
  2380.                     ,0xBCD   => 9
  2381.                     ,0xC4D   => 9
  2382.                     ,0xCCD   => 9
  2383.                     ,0xD4D   => 9
  2384.                     ,0xDCA   => 9
  2385.                     ,0xE3A   => 9
  2386.                     ,0xF84   => 9
  2387.                     ,0x1039  => 9
  2388.                     ,0x1714  => 9
  2389.                     ,0x1734  => 9
  2390.                     ,0x17D2  => 9
  2391.                     ,0x5B0   => 10
  2392.                     ,0x5B1   => 11
  2393.                     ,0x5B2   => 12
  2394.                     ,0x5B3   => 13
  2395.                     ,0x5B4   => 14
  2396.                     ,0x5B5   => 15
  2397.                     ,0x5B6   => 16
  2398.                     ,0x5B7   => 17
  2399.                     ,0x5B8   => 18
  2400.                     ,0x5B9   => 19
  2401.                     ,0x5BB   => 20
  2402.                     ,0x5Bc   => 21
  2403.                     ,0x5BD   => 22
  2404.                     ,0x5BF   => 23
  2405.                     ,0x5C1   => 24
  2406.                     ,0x5C2   => 25
  2407.                     ,0xFB1E  => 26
  2408.                     ,0x64B   => 27
  2409.                     ,0x64C   => 28
  2410.                     ,0x64D   => 29
  2411.                     ,0x64E   => 30
  2412.                     ,0x64F   => 31
  2413.                     ,0x650   => 32
  2414.                     ,0x651   => 33
  2415.                     ,0x652   => 34
  2416.                     ,0x670   => 35
  2417.                     ,0x711   => 36
  2418.                     ,0xC55   => 84
  2419.                     ,0xC56   => 91
  2420.                     ,0xE38   => 103
  2421.                     ,0xE39   => 103
  2422.                     ,0xE48   => 107
  2423.                     ,0xE49   => 107
  2424.                     ,0xE4A   => 107
  2425.                     ,0xE4B   => 107
  2426.                     ,0xEB8   => 118
  2427.                     ,0xEB9   => 118
  2428.                     ,0xEC8   => 122
  2429.                     ,0xEC9   => 122
  2430.                     ,0xECA   => 122
  2431.                     ,0xECB   => 122
  2432.                     ,0xF71   => 129
  2433.                     ,0xF72   => 130
  2434.                     ,0xF7A   => 130
  2435.                     ,0xF7B   => 130
  2436.                     ,0xF7C   => 130
  2437.                     ,0xF7D   => 130
  2438.                     ,0xF80   => 130
  2439.                     ,0xF74   => 132
  2440.                     ,0x321   => 202
  2441.                     ,0x322   => 202
  2442.                     ,0x327   => 202
  2443.                     ,0x328   => 202
  2444.                     ,0x31B   => 216
  2445.                     ,0xF39   => 216
  2446.                     ,0x1D165 => 216
  2447.                     ,0x1D166 => 216
  2448.                     ,0x1D16E => 216
  2449.                     ,0x1D16F => 216
  2450.                     ,0x1D170 => 216
  2451.                     ,0x1D171 => 216
  2452.                     ,0x1D172 => 216
  2453.                     ,0x302A  => 218
  2454.                     ,0x316   => 220
  2455.                     ,0x317   => 220
  2456.                     ,0x318   => 220
  2457.                     ,0x319   => 220
  2458.                     ,0x31C   => 220
  2459.                     ,0x31D   => 220
  2460.                     ,0x31E   => 220
  2461.                     ,0x31F   => 220
  2462.                     ,0x320   => 220
  2463.                     ,0x323   => 220
  2464.                     ,0x324   => 220
  2465.                     ,0x325   => 220
  2466.                     ,0x326   => 220
  2467.                     ,0x329   => 220
  2468.                     ,0x32A   => 220
  2469.                     ,0x32B   => 220
  2470.                     ,0x32C   => 220
  2471.                     ,0x32D   => 220
  2472.                     ,0x32E   => 220
  2473.                     ,0x32F   => 220
  2474.                     ,0x330   => 220
  2475.                     ,0x331   => 220
  2476.                     ,0x332   => 220
  2477.                     ,0x333   => 220
  2478.                     ,0x339   => 220
  2479.                     ,0x33A   => 220
  2480.                     ,0x33B   => 220
  2481.                     ,0x33C   => 220
  2482.                     ,0x347   => 220
  2483.                     ,0x348   => 220
  2484.                     ,0x349   => 220
  2485.                     ,0x34D   => 220
  2486.                     ,0x34E   => 220
  2487.                     ,0x353   => 220
  2488.                     ,0x354   => 220
  2489.                     ,0x355   => 220
  2490.                     ,0x356   => 220
  2491.                     ,0x591   => 220
  2492.                     ,0x596   => 220
  2493.                     ,0x59B   => 220
  2494.                     ,0x5A3   => 220
  2495.                     ,0x5A4   => 220
  2496.                     ,0x5A5   => 220
  2497.                     ,0x5A6   => 220
  2498.                     ,0x5A7   => 220
  2499.                     ,0x5AA   => 220
  2500.                     ,0x655   => 220
  2501.                     ,0x656   => 220
  2502.                     ,0x6E3   => 220
  2503.                     ,0x6EA   => 220
  2504.                     ,0x6ED   => 220
  2505.                     ,0x731   => 220
  2506.                     ,0x734   => 220
  2507.                     ,0x737   => 220
  2508.                     ,0x738   => 220
  2509.                     ,0x739   => 220
  2510.                     ,0x73B   => 220
  2511.                     ,0x73C   => 220
  2512.                     ,0x73E   => 220
  2513.                     ,0x742   => 220
  2514.                     ,0x744   => 220
  2515.                     ,0x746   => 220
  2516.                     ,0x748   => 220
  2517.                     ,0x952   => 220
  2518.                     ,0xF18   => 220
  2519.                     ,0xF19   => 220
  2520.                     ,0xF35   => 220
  2521.                     ,0xF37   => 220
  2522.                     ,0xFC6   => 220
  2523.                     ,0x193B  => 220
  2524.                     ,0x20E8  => 220
  2525.                     ,0x1D17B => 220
  2526.                     ,0x1D17C => 220
  2527.                     ,0x1D17D => 220
  2528.                     ,0x1D17E => 220
  2529.                     ,0x1D17F => 220
  2530.                     ,0x1D180 => 220
  2531.                     ,0x1D181 => 220
  2532.                     ,0x1D182 => 220
  2533.                     ,0x1D18A => 220
  2534.                     ,0x1D18B => 220
  2535.                     ,0x59A   => 222
  2536.                     ,0x5AD   => 222
  2537.                     ,0x1929  => 222
  2538.                     ,0x302D  => 222
  2539.                     ,0x302E  => 224
  2540.                     ,0x302F  => 224
  2541.                     ,0x1D16D => 226
  2542.                     ,0x5AE   => 228
  2543.                     ,0x18A9  => 228
  2544.                     ,0x302B  => 228
  2545.                     ,0x300   => 230
  2546.                     ,0x301   => 230
  2547.                     ,0x302   => 230
  2548.                     ,0x303   => 230
  2549.                     ,0x304   => 230
  2550.                     ,0x305   => 230
  2551.                     ,0x306   => 230
  2552.                     ,0x307   => 230
  2553.                     ,0x308   => 230
  2554.                     ,0x309   => 230
  2555.                     ,0x30A   => 230
  2556.                     ,0x30B   => 230
  2557.                     ,0x30C   => 230
  2558.                     ,0x30D   => 230
  2559.                     ,0x30E   => 230
  2560.                     ,0x30F   => 230
  2561.                     ,0x310   => 230
  2562.                     ,0x311   => 230
  2563.                     ,0x312   => 230
  2564.                     ,0x313   => 230
  2565.                     ,0x314   => 230
  2566.                     ,0x33D   => 230
  2567.                     ,0x33E   => 230
  2568.                     ,0x33F   => 230
  2569.                     ,0x340   => 230
  2570.                     ,0x341   => 230
  2571.                     ,0x342   => 230
  2572.                     ,0x343   => 230
  2573.                     ,0x344   => 230
  2574.                     ,0x346   => 230
  2575.                     ,0x34A   => 230
  2576.                     ,0x34B   => 230
  2577.                     ,0x34C   => 230
  2578.                     ,0x350   => 230
  2579.                     ,0x351   => 230
  2580.                     ,0x352   => 230
  2581.                     ,0x357   => 230
  2582.                     ,0x363   => 230
  2583.                     ,0x364   => 230
  2584.                     ,0x365   => 230
  2585.                     ,0x366   => 230
  2586.                     ,0x367   => 230
  2587.                     ,0x368   => 230
  2588.                     ,0x369   => 230
  2589.                     ,0x36A   => 230
  2590.                     ,0x36B   => 230
  2591.                     ,0x36C   => 230
  2592.                     ,0x36D   => 230
  2593.                     ,0x36E   => 230
  2594.                     ,0x36F   => 230
  2595.                     ,0x483   => 230
  2596.                     ,0x484   => 230
  2597.                     ,0x485   => 230
  2598.                     ,0x486   => 230
  2599.                     ,0x592   => 230
  2600.                     ,0x593   => 230
  2601.                     ,0x594   => 230
  2602.                     ,0x595   => 230
  2603.                     ,0x597   => 230
  2604.                     ,0x598   => 230
  2605.                     ,0x599   => 230
  2606.                     ,0x59C   => 230
  2607.                     ,0x59D   => 230
  2608.                     ,0x59E   => 230
  2609.                     ,0x59F   => 230
  2610.                     ,0x5A0   => 230
  2611.                     ,0x5A1   => 230
  2612.                     ,0x5A8   => 230
  2613.                     ,0x5A9   => 230
  2614.                     ,0x5AB   => 230
  2615.                     ,0x5AC   => 230
  2616.                     ,0x5AF   => 230
  2617.                     ,0x5C4   => 230
  2618.                     ,0x610   => 230
  2619.                     ,0x611   => 230
  2620.                     ,0x612   => 230
  2621.                     ,0x613   => 230
  2622.                     ,0x614   => 230
  2623.                     ,0x615   => 230
  2624.                     ,0x653   => 230
  2625.                     ,0x654   => 230
  2626.                     ,0x657   => 230
  2627.                     ,0x658   => 230
  2628.                     ,0x6D6   => 230
  2629.                     ,0x6D7   => 230
  2630.                     ,0x6D8   => 230
  2631.                     ,0x6D9   => 230
  2632.                     ,0x6DA   => 230
  2633.                     ,0x6DB   => 230
  2634.                     ,0x6DC   => 230
  2635.                     ,0x6DF   => 230
  2636.                     ,0x6E0   => 230
  2637.                     ,0x6E1   => 230
  2638.                     ,0x6E2   => 230
  2639.                     ,0x6E4   => 230
  2640.                     ,0x6E7   => 230
  2641.                     ,0x6E8   => 230
  2642.                     ,0x6EB   => 230
  2643.                     ,0x6EC   => 230
  2644.                     ,0x730   => 230
  2645.                     ,0x732   => 230
  2646.                     ,0x733   => 230
  2647.                     ,0x735   => 230
  2648.                     ,0x736   => 230
  2649.                     ,0x73A   => 230
  2650.                     ,0x73D   => 230
  2651.                     ,0x73F   => 230
  2652.                     ,0x740   => 230
  2653.                     ,0x741   => 230
  2654.                     ,0x743   => 230
  2655.                     ,0x745   => 230
  2656.                     ,0x747   => 230
  2657.                     ,0x749   => 230
  2658.                     ,0x74A   => 230
  2659.                     ,0x951   => 230
  2660.                     ,0x953   => 230
  2661.                     ,0x954   => 230
  2662.                     ,0xF82   => 230
  2663.                     ,0xF83   => 230
  2664.                     ,0xF86   => 230
  2665.                     ,0xF87   => 230
  2666.                     ,0x170D  => 230
  2667.                     ,0x193A  => 230
  2668.                     ,0x20D0  => 230
  2669.                     ,0x20D1  => 230
  2670.                     ,0x20D4  => 230
  2671.                     ,0x20D5  => 230
  2672.                     ,0x20D6  => 230
  2673.                     ,0x20D7  => 230
  2674.                     ,0x20DB  => 230
  2675.                     ,0x20DC  => 230
  2676.                     ,0x20E1  => 230
  2677.                     ,0x20E7  => 230
  2678.                     ,0x20E9  => 230
  2679.                     ,0xFE20  => 230
  2680.                     ,0xFE21  => 230
  2681.                     ,0xFE22  => 230
  2682.                     ,0xFE23  => 230
  2683.                     ,0x1D185 => 230
  2684.                     ,0x1D186 => 230
  2685.                     ,0x1D187 => 230
  2686.                     ,0x1D189 => 230
  2687.                     ,0x1D188 => 230
  2688.                     ,0x1D1AA => 230
  2689.                     ,0x1D1AB => 230
  2690.                     ,0x1D1AC => 230
  2691.                     ,0x1D1AD => 230
  2692.                     ,0x315   => 232
  2693.                     ,0x31A   => 232
  2694.                     ,0x302C  => 232
  2695.                     ,0x35F   => 233
  2696.                     ,0x362   => 233
  2697.                     ,0x35D   => 234
  2698.                     ,0x35E   => 234
  2699.                     ,0x360   => 234
  2700.                     ,0x361   => 234
  2701.                     ,0x345   => 240
  2702.                     )
  2703.             );
  2704. }
  2705. ?>
main

Packages

main
admin
admin-skin
AmCode
collections
conf
evocore
evoskins
htsrv
install
libs
maintenance
MCFileManager-filesystems
MCManager-includes
MCManager-utils
messaging
plugins
sessions
skins
xmlsrv

Documentation generated on Sat, 06 Mar 2010 04:13:42 +0100 by phpDocumentor 1.4.2. This site is hosted and maintained by Daniel HAHLER (Contact).