<h2>Edit File - IDNA2.php</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/opt/alt/php71/usr/share/pear/Net/IDNA2.php">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&lt;?php

// {{{ license

/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4 foldmethod=marker: */
//
// +----------------------------------------------------------------------+
// | This library is free software; you can redistribute it and/or modify |
// | it under the terms of the GNU Lesser General Public License as       |
// | published by the Free Software Foundation; either version 2.1 of the |
// | License, or (at your option) any later version.                      |
// |                                                                      |
// | This library is distributed in the hope that it will be useful, but  |
// | WITHOUT ANY WARRANTY; without even the implied warranty of           |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    |
// | Lesser General Public License for more details.                      |
// |                                                                      |
// | You should have received a copy of the GNU Lesser General Public     |
// | License along with this library; if not, write to the Free Software  |
// | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 |
// | USA.                                                                 |
// +----------------------------------------------------------------------+
//

// }}}
require_once &#039;Net/IDNA2/Exception.php&#039;;
require_once &#039;Net/IDNA2/Exception/Nameprep.php&#039;;

/**
 * Encode/decode Internationalized Domain Names.
 *
 * The class allows one to convert internationalized domain names
 * (see RFC 3490 for details) as they can be used with various registries worldwide
 * to be translated between their original (localized) form and their encoded form
 * as it will be used in the DNS (Domain Name System).
 *
 * The class provides two public methods, encode() and decode(), which do exactly
 * what you would expect them to do. You are allowed to use complete domain names,
 * simple strings and complete email addresses as well. That means, that you might
 * use any of the following notations:
 *
 * - www.n�rgler.com
 * - xn--nrgler-wxa
 * - xn--brse-5qa.xn--knrz-1ra.info
 *
 * Unicode input might be given as either UTF-8 string, UCS-4 string or UCS-4
 * array. Unicode output is available in the same formats.
 * You can select your preferred format via {@link set_paramter()}.
 *
 * ACE input and output is always expected to be ASCII.
 *
 * @package Net
 * @author  Markus Nix &lt;mnix@docuverse.de&gt;
 * @author  Matthias Sommerfeld &lt;mso@phlylabs.de&gt;
 * @author  Stefan Neufeind &lt;pear.neufeind@speedpartner.de&gt;
 * @version $Id$
 */
class Net_IDNA2
{
    // {{{ npdata
    /**
     * These Unicode codepoints are
     * mapped to nothing, See RFC3454 for details
     *
     * @static
     * @var array
     * @access private
     */
    private static $_np_map_nothing = array(
        0xAD,
        0x34F,
        0x1806,
        0x180B,
        0x180C,
        0x180D,
        0x200B,
        0x200C,
        0x200D,
        0x2060,
        0xFE00,
        0xFE01,
        0xFE02,
        0xFE03,
        0xFE04,
        0xFE05,
        0xFE06,
        0xFE07,
        0xFE08,
        0xFE09,
        0xFE0A,
        0xFE0B,
        0xFE0C,
        0xFE0D,
        0xFE0E,
        0xFE0F,
        0xFEFF
    );

    /**
     * Prohibited codepints
     *
     * @static
     * @var array
     * @access private
     */
    private static $_general_prohibited = array(
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8,
        9,
        0xA,
        0xB,
        0xC,
        0xD,
        0xE,
        0xF,
        0x10,
        0x11,
        0x12,
        0x13,
        0x14,
        0x15,
        0x16,
        0x17,
        0x18,
        0x19,
        0x1A,
        0x1B,
        0x1C,
        0x1D,
        0x1E,
        0x1F,
        0x20,
        0x21,
        0x22,
        0x23,
        0x24,
        0x25,
        0x26,
        0x27,
        0x28,
        0x29,
        0x2A,
        0x2B,
        0x2C,
        0x2F,
        0x3B,
        0x3C,
        0x3D,
        0x3E,
        0x3F,
        0x40,
        0x5B,
        0x5C,
        0x5D,
        0x5E,
        0x5F,
        0x60,
        0x7B,
        0x7C,
        0x7D,
        0x7E,
        0x7F,
        0x3002
    );

    /**
     * Codepints prohibited by Nameprep
     * @static
     * @var array
     * @access private
     */
    private static $_np_prohibit = array(
        0xA0,
        0x1680,
        0x2000,
        0x2001,
        0x2002,
        0x2003,
        0x2004,
        0x2005,
        0x2006,
        0x2007,
        0x2008,
        0x2009,
        0x200A,
        0x200B,
        0x202F,
        0x205F,
        0x3000,
        0x6DD,
        0x70F,
        0x180E,
        0x200C,
        0x200D,
        0x2028,
        0x2029,
        0xFEFF,
        0xFFF9,
        0xFFFA,
        0xFFFB,
        0xFFFC,
        0xFFFE,
        0xFFFF,
        0x1FFFE,
        0x1FFFF,
        0x2FFFE,
        0x2FFFF,
        0x3FFFE,
        0x3FFFF,
        0x4FFFE,
        0x4FFFF,
        0x5FFFE,
        0x5FFFF,
        0x6FFFE,
        0x6FFFF,
        0x7FFFE,
        0x7FFFF,
        0x8FFFE,
        0x8FFFF,
        0x9FFFE,
        0x9FFFF,
        0xAFFFE,
        0xAFFFF,
        0xBFFFE,
        0xBFFFF,
        0xCFFFE,
        0xCFFFF,
        0xDFFFE,
        0xDFFFF,
        0xEFFFE,
        0xEFFFF,
        0xFFFFE,
        0xFFFFF,
        0x10FFFE,
        0x10FFFF,
        0xFFF9,
        0xFFFA,
        0xFFFB,
        0xFFFC,
        0xFFFD,
        0x340,
        0x341,
        0x200E,
        0x200F,
        0x202A,
        0x202B,
        0x202C,
        0x202D,
        0x202E,
        0x206A,
        0x206B,
        0x206C,
        0x206D,
        0x206E,
        0x206F,
        0xE0001
    );

    /**
     * Codepoint ranges prohibited by nameprep
     *
     * @static
     * @var array
     * @access private
     */
    private static $_np_prohibit_ranges = array(
        array(0x80,     0x9F    ),
        array(0x2060,   0x206F  ),
        array(0x1D173,  0x1D17A ),
        array(0xE000,   0xF8FF  ),
        array(0xF0000,  0xFFFFD ),
        array(0x100000, 0x10FFFD),
        array(0xFDD0,   0xFDEF  ),
        array(0xD800,   0xDFFF  ),
        array(0x2FF0,   0x2FFB  ),
        array(0xE0020,  0xE007F )
    );

    /**
     * Replacement mappings (casemapping, replacement sequences, ...)
     *
     * @static
     * @var array
     * @access private
     */
    private static $_np_replacemaps = array(
        0x41    =&gt; array(0x61),
        0x42    =&gt; array(0x62),
        0x43    =&gt; array(0x63),
        0x44    =&gt; array(0x64),
        0x45    =&gt; array(0x65),
        0x46    =&gt; array(0x66),
        0x47    =&gt; array(0x67),
        0x48    =&gt; array(0x68),
        0x49    =&gt; array(0x69),
        0x4A    =&gt; array(0x6A),
        0x4B    =&gt; array(0x6B),
        0x4C    =&gt; array(0x6C),
        0x4D    =&gt; array(0x6D),
        0x4E    =&gt; array(0x6E),
        0x4F    =&gt; array(0x6F),
        0x50    =&gt; array(0x70),
        0x51    =&gt; array(0x71),
        0x52    =&gt; array(0x72),
        0x53    =&gt; array(0x73),
        0x54    =&gt; array(0x74),
        0x55    =&gt; array(0x75),
        0x56    =&gt; array(0x76),
        0x57    =&gt; array(0x77),
        0x58    =&gt; array(0x78),
        0x59    =&gt; array(0x79),
        0x5A    =&gt; array(0x7A),
        0xB5    =&gt; array(0x3BC),
        0xC0    =&gt; array(0xE0),
        0xC1    =&gt; array(0xE1),
        0xC2    =&gt; array(0xE2),
        0xC3    =&gt; array(0xE3),
        0xC4    =&gt; array(0xE4),
        0xC5    =&gt; array(0xE5),
        0xC6    =&gt; array(0xE6),
        0xC7    =&gt; array(0xE7),
        0xC8    =&gt; array(0xE8),
        0xC9    =&gt; array(0xE9),
        0xCA    =&gt; array(0xEA),
        0xCB    =&gt; array(0xEB),
        0xCC    =&gt; array(0xEC),
        0xCD    =&gt; array(0xED),
        0xCE    =&gt; array(0xEE),
        0xCF    =&gt; array(0xEF),
        0xD0    =&gt; array(0xF0),
        0xD1    =&gt; array(0xF1),
        0xD2    =&gt; array(0xF2),
        0xD3    =&gt; array(0xF3),
        0xD4    =&gt; array(0xF4),
        0xD5    =&gt; array(0xF5),
        0xD6    =&gt; array(0xF6),
        0xD8    =&gt; array(0xF8),
        0xD9    =&gt; array(0xF9),
        0xDA    =&gt; array(0xFA),
        0xDB    =&gt; array(0xFB),
        0xDC    =&gt; array(0xFC),
        0xDD    =&gt; array(0xFD),
        0xDE    =&gt; array(0xFE),
        0xDF    =&gt; array(0x73, 0x73),
        0x100   =&gt; array(0x101),
        0x102   =&gt; array(0x103),
        0x104   =&gt; array(0x105),
        0x106   =&gt; array(0x107),
        0x108   =&gt; array(0x109),
        0x10A   =&gt; array(0x10B),
        0x10C   =&gt; array(0x10D),
        0x10E   =&gt; array(0x10F),
        0x110   =&gt; array(0x111),
        0x112   =&gt; array(0x113),
        0x114   =&gt; array(0x115),
        0x116   =&gt; array(0x117),
        0x118   =&gt; array(0x119),
        0x11A   =&gt; array(0x11B),
        0x11C   =&gt; array(0x11D),
        0x11E   =&gt; array(0x11F),
        0x120   =&gt; array(0x121),
        0x122   =&gt; array(0x123),
        0x124   =&gt; array(0x125),
        0x126   =&gt; array(0x127),
        0x128   =&gt; array(0x129),
        0x12A   =&gt; array(0x12B),
        0x12C   =&gt; array(0x12D),
        0x12E   =&gt; array(0x12F),
        0x130   =&gt; array(0x69, 0x307),
        0x132   =&gt; array(0x133),
        0x134   =&gt; array(0x135),
        0x136   =&gt; array(0x137),
        0x139   =&gt; array(0x13A),
        0x13B   =&gt; array(0x13C),
        0x13D   =&gt; array(0x13E),
        0x13F   =&gt; array(0x140),
        0x141   =&gt; array(0x142),
        0x143   =&gt; array(0x144),
        0x145   =&gt; array(0x146),
        0x147   =&gt; array(0x148),
        0x149   =&gt; array(0x2BC, 0x6E),
        0x14A   =&gt; array(0x14B),
        0x14C   =&gt; array(0x14D),
        0x14E   =&gt; array(0x14F),
        0x150   =&gt; array(0x151),
        0x152   =&gt; array(0x153),
        0x154   =&gt; array(0x155),
        0x156   =&gt; array(0x157),
        0x158   =&gt; array(0x159),
        0x15A   =&gt; array(0x15B),
        0x15C   =&gt; array(0x15D),
        0x15E   =&gt; array(0x15F),
        0x160   =&gt; array(0x161),
        0x162   =&gt; array(0x163),
        0x164   =&gt; array(0x165),
        0x166   =&gt; array(0x167),
        0x168   =&gt; array(0x169),
        0x16A   =&gt; array(0x16B),
        0x16C   =&gt; array(0x16D),
        0x16E   =&gt; array(0x16F),
        0x170   =&gt; array(0x171),
        0x172   =&gt; array(0x173),
        0x174   =&gt; array(0x175),
        0x176   =&gt; array(0x177),
        0x178   =&gt; array(0xFF),
        0x179   =&gt; array(0x17A),
        0x17B   =&gt; array(0x17C),
        0x17D   =&gt; array(0x17E),
        0x17F   =&gt; array(0x73),
        0x181   =&gt; array(0x253),
        0x182   =&gt; array(0x183),
        0x184   =&gt; array(0x185),
        0x186   =&gt; array(0x254),
        0x187   =&gt; array(0x188),
        0x189   =&gt; array(0x256),
        0x18A   =&gt; array(0x257),
        0x18B   =&gt; array(0x18C),
        0x18E   =&gt; array(0x1DD),
        0x18F   =&gt; array(0x259),
        0x190   =&gt; array(0x25B),
        0x191   =&gt; array(0x192),
        0x193   =&gt; array(0x260),
        0x194   =&gt; array(0x263),
        0x196   =&gt; array(0x269),
        0x197   =&gt; array(0x268),
        0x198   =&gt; array(0x199),
        0x19C   =&gt; array(0x26F),
        0x19D   =&gt; array(0x272),
        0x19F   =&gt; array(0x275),
        0x1A0   =&gt; array(0x1A1),
        0x1A2   =&gt; array(0x1A3),
        0x1A4   =&gt; array(0x1A5),
        0x1A6   =&gt; array(0x280),
        0x1A7   =&gt; array(0x1A8),
        0x1A9   =&gt; array(0x283),
        0x1AC   =&gt; array(0x1AD),
        0x1AE   =&gt; array(0x288),
        0x1AF   =&gt; array(0x1B0),
        0x1B1   =&gt; array(0x28A),
        0x1B2   =&gt; array(0x28B),
        0x1B3   =&gt; array(0x1B4),
        0x1B5   =&gt; array(0x1B6),
        0x1B7   =&gt; array(0x292),
        0x1B8   =&gt; array(0x1B9),
        0x1BC   =&gt; array(0x1BD),
        0x1C4   =&gt; array(0x1C6),
        0x1C5   =&gt; array(0x1C6),
        0x1C7   =&gt; array(0x1C9),
        0x1C8   =&gt; array(0x1C9),
        0x1CA   =&gt; array(0x1CC),
        0x1CB   =&gt; array(0x1CC),
        0x1CD   =&gt; array(0x1CE),
        0x1CF   =&gt; array(0x1D0),
        0x1D1   =&gt; array(0x1D2),
        0x1D3   =&gt; array(0x1D4),
        0x1D5   =&gt; array(0x1D6),
        0x1D7   =&gt; array(0x1D8),
        0x1D9   =&gt; array(0x1DA),
        0x1DB   =&gt; array(0x1DC),
        0x1DE   =&gt; array(0x1DF),
        0x1E0   =&gt; array(0x1E1),
        0x1E2   =&gt; array(0x1E3),
        0x1E4   =&gt; array(0x1E5),
        0x1E6   =&gt; array(0x1E7),
        0x1E8   =&gt; array(0x1E9),
        0x1EA   =&gt; array(0x1EB),
        0x1EC   =&gt; array(0x1ED),
        0x1EE   =&gt; array(0x1EF),
        0x1F0   =&gt; array(0x6A, 0x30C),
        0x1F1   =&gt; array(0x1F3),
        0x1F2   =&gt; array(0x1F3),
        0x1F4   =&gt; array(0x1F5),
        0x1F6   =&gt; array(0x195),
        0x1F7   =&gt; array(0x1BF),
        0x1F8   =&gt; array(0x1F9),
        0x1FA   =&gt; array(0x1FB),
        0x1FC   =&gt; array(0x1FD),
        0x1FE   =&gt; array(0x1FF),
        0x200   =&gt; array(0x201),
        0x202   =&gt; array(0x203),
        0x204   =&gt; array(0x205),
        0x206   =&gt; array(0x207),
        0x208   =&gt; array(0x209),
        0x20A   =&gt; array(0x20B),
        0x20C   =&gt; array(0x20D),
        0x20E   =&gt; array(0x20F),
        0x210   =&gt; array(0x211),
        0x212   =&gt; array(0x213),
        0x214   =&gt; array(0x215),
        0x216   =&gt; array(0x217),
        0x218   =&gt; array(0x219),
        0x21A   =&gt; array(0x21B),
        0x21C   =&gt; array(0x21D),
        0x21E   =&gt; array(0x21F),
        0x220   =&gt; array(0x19E),
        0x222   =&gt; array(0x223),
        0x224   =&gt; array(0x225),
        0x226   =&gt; array(0x227),
        0x228   =&gt; array(0x229),
        0x22A   =&gt; array(0x22B),
        0x22C   =&gt; array(0x22D),
        0x22E   =&gt; array(0x22F),
        0x230   =&gt; array(0x231),
        0x232   =&gt; array(0x233),
        0x345   =&gt; array(0x3B9),
        0x37A   =&gt; array(0x20, 0x3B9),
        0x386   =&gt; array(0x3AC),
        0x388   =&gt; array(0x3AD),
        0x389   =&gt; array(0x3AE),
        0x38A   =&gt; array(0x3AF),
        0x38C   =&gt; array(0x3CC),
        0x38E   =&gt; array(0x3CD),
        0x38F   =&gt; array(0x3CE),
        0x390   =&gt; array(0x3B9, 0x308, 0x301),
        0x391   =&gt; array(0x3B1),
        0x392   =&gt; array(0x3B2),
        0x393   =&gt; array(0x3B3),
        0x394   =&gt; array(0x3B4),
        0x395   =&gt; array(0x3B5),
        0x396   =&gt; array(0x3B6),
        0x397   =&gt; array(0x3B7),
        0x398   =&gt; array(0x3B8),
        0x399   =&gt; array(0x3B9),
        0x39A   =&gt; array(0x3BA),
        0x39B   =&gt; array(0x3BB),
        0x39C   =&gt; array(0x3BC),
        0x39D   =&gt; array(0x3BD),
        0x39E   =&gt; array(0x3BE),
        0x39F   =&gt; array(0x3BF),
        0x3A0   =&gt; array(0x3C0),
        0x3A1   =&gt; array(0x3C1),
        0x3A3   =&gt; array(0x3C3),
        0x3A4   =&gt; array(0x3C4),
        0x3A5   =&gt; array(0x3C5),
        0x3A6   =&gt; array(0x3C6),
        0x3A7   =&gt; array(0x3C7),
        0x3A8   =&gt; array(0x3C8),
        0x3A9   =&gt; array(0x3C9),
        0x3AA   =&gt; array(0x3CA),
        0x3AB   =&gt; array(0x3CB),
        0x3B0   =&gt; array(0x3C5, 0x308, 0x301),
        0x3C2   =&gt; array(0x3C3),
        0x3D0   =&gt; array(0x3B2),
        0x3D1   =&gt; array(0x3B8),
        0x3D2   =&gt; array(0x3C5),
        0x3D3   =&gt; array(0x3CD),
        0x3D4   =&gt; array(0x3CB),
        0x3D5   =&gt; array(0x3C6),
        0x3D6   =&gt; array(0x3C0),
        0x3D8   =&gt; array(0x3D9),
        0x3DA   =&gt; array(0x3DB),
        0x3DC   =&gt; array(0x3DD),
        0x3DE   =&gt; array(0x3DF),
        0x3E0   =&gt; array(0x3E1),
        0x3E2   =&gt; array(0x3E3),
        0x3E4   =&gt; array(0x3E5),
        0x3E6   =&gt; array(0x3E7),
        0x3E8   =&gt; array(0x3E9),
        0x3EA   =&gt; array(0x3EB),
        0x3EC   =&gt; array(0x3ED),
        0x3EE   =&gt; array(0x3EF),
        0x3F0   =&gt; array(0x3BA),
        0x3F1   =&gt; array(0x3C1),
        0x3F2   =&gt; array(0x3C3),
        0x3F4   =&gt; array(0x3B8),
        0x3F5   =&gt; array(0x3B5),
        0x400   =&gt; array(0x450),
        0x401   =&gt; array(0x451),
        0x402   =&gt; array(0x452),
        0x403   =&gt; array(0x453),
        0x404   =&gt; array(0x454),
        0x405   =&gt; array(0x455),
        0x406   =&gt; array(0x456),
        0x407   =&gt; array(0x457),
        0x408   =&gt; array(0x458),
        0x409   =&gt; array(0x459),
        0x40A   =&gt; array(0x45A),
        0x40B   =&gt; array(0x45B),
        0x40C   =&gt; array(0x45C),
        0x40D   =&gt; array(0x45D),
        0x40E   =&gt; array(0x45E),
        0x40F   =&gt; array(0x45F),
        0x410   =&gt; array(0x430),
        0x411   =&gt; array(0x431),
        0x412   =&gt; array(0x432),
        0x413   =&gt; array(0x433),
        0x414   =&gt; array(0x434),
        0x415   =&gt; array(0x435),
        0x416   =&gt; array(0x436),
        0x417   =&gt; array(0x437),
        0x418   =&gt; array(0x438),
        0x419   =&gt; array(0x439),
        0x41A   =&gt; array(0x43A),
        0x41B   =&gt; array(0x43B),
        0x41C   =&gt; array(0x43C),
        0x41D   =&gt; array(0x43D),
        0x41E   =&gt; array(0x43E),
        0x41F   =&gt; array(0x43F),
        0x420   =&gt; array(0x440),
        0x421   =&gt; array(0x441),
        0x422   =&gt; array(0x442),
        0x423   =&gt; array(0x443),
        0x424   =&gt; array(0x444),
        0x425   =&gt; array(0x445),
        0x426   =&gt; array(0x446),
        0x427   =&gt; array(0x447),
        0x428   =&gt; array(0x448),
        0x429   =&gt; array(0x449),
        0x42A   =&gt; array(0x44A),
        0x42B   =&gt; array(0x44B),
        0x42C   =&gt; array(0x44C),
        0x42D   =&gt; array(0x44D),
        0x42E   =&gt; array(0x44E),
        0x42F   =&gt; array(0x44F),
        0x460   =&gt; array(0x461),
        0x462   =&gt; array(0x463),
        0x464   =&gt; array(0x465),
        0x466   =&gt; array(0x467),
        0x468   =&gt; array(0x469),
        0x46A   =&gt; array(0x46B),
        0x46C   =&gt; array(0x46D),
        0x46E   =&gt; array(0x46F),
        0x470   =&gt; array(0x471),
        0x472   =&gt; array(0x473),
        0x474   =&gt; array(0x475),
        0x476   =&gt; array(0x477),
        0x478   =&gt; array(0x479),
        0x47A   =&gt; array(0x47B),
        0x47C   =&gt; array(0x47D),
        0x47E   =&gt; array(0x47F),
        0x480   =&gt; array(0x481),
        0x48A   =&gt; array(0x48B),
        0x48C   =&gt; array(0x48D),
        0x48E   =&gt; array(0x48F),
        0x490   =&gt; array(0x491),
        0x492   =&gt; array(0x493),
        0x494   =&gt; array(0x495),
        0x496   =&gt; array(0x497),
        0x498   =&gt; array(0x499),
        0x49A   =&gt; array(0x49B),
        0x49C   =&gt; array(0x49D),
        0x49E   =&gt; array(0x49F),
        0x4A0   =&gt; array(0x4A1),
        0x4A2   =&gt; array(0x4A3),
        0x4A4   =&gt; array(0x4A5),
        0x4A6   =&gt; array(0x4A7),
        0x4A8   =&gt; array(0x4A9),
        0x4AA   =&gt; array(0x4AB),
        0x4AC   =&gt; array(0x4AD),
        0x4AE   =&gt; array(0x4AF),
        0x4B0   =&gt; array(0x4B1),
        0x4B2   =&gt; array(0x4B3),
        0x4B4   =&gt; array(0x4B5),
        0x4B6   =&gt; array(0x4B7),
        0x4B8   =&gt; array(0x4B9),
        0x4BA   =&gt; array(0x4BB),
        0x4BC   =&gt; array(0x4BD),
        0x4BE   =&gt; array(0x4BF),
        0x4C1   =&gt; array(0x4C2),
        0x4C3   =&gt; array(0x4C4),
        0x4C5   =&gt; array(0x4C6),
        0x4C7   =&gt; array(0x4C8),
        0x4C9   =&gt; array(0x4CA),
        0x4CB   =&gt; array(0x4CC),
        0x4CD   =&gt; array(0x4CE),
        0x4D0   =&gt; array(0x4D1),
        0x4D2   =&gt; array(0x4D3),
        0x4D4   =&gt; array(0x4D5),
        0x4D6   =&gt; array(0x4D7),
        0x4D8   =&gt; array(0x4D9),
        0x4DA   =&gt; array(0x4DB),
        0x4DC   =&gt; array(0x4DD),
        0x4DE   =&gt; array(0x4DF),
        0x4E0   =&gt; array(0x4E1),
        0x4E2   =&gt; array(0x4E3),
        0x4E4   =&gt; array(0x4E5),
        0x4E6   =&gt; array(0x4E7),
        0x4E8   =&gt; array(0x4E9),
        0x4EA   =&gt; array(0x4EB),
        0x4EC   =&gt; array(0x4ED),
        0x4EE   =&gt; array(0x4EF),
        0x4F0   =&gt; array(0x4F1),
        0x4F2   =&gt; array(0x4F3),
        0x4F4   =&gt; array(0x4F5),
        0x4F8   =&gt; array(0x4F9),
        0x500   =&gt; array(0x501),
        0x502   =&gt; array(0x503),
        0x504   =&gt; array(0x505),
        0x506   =&gt; array(0x507),
        0x508   =&gt; array(0x509),
        0x50A   =&gt; array(0x50B),
        0x50C   =&gt; array(0x50D),
        0x50E   =&gt; array(0x50F),
        0x531   =&gt; array(0x561),
        0x532   =&gt; array(0x562),
        0x533   =&gt; array(0x563),
        0x534   =&gt; array(0x564),
        0x535   =&gt; array(0x565),
        0x536   =&gt; array(0x566),
        0x537   =&gt; array(0x567),
        0x538   =&gt; array(0x568),
        0x539   =&gt; array(0x569),
        0x53A   =&gt; array(0x56A),
        0x53B   =&gt; array(0x56B),
        0x53C   =&gt; array(0x56C),
        0x53D   =&gt; array(0x56D),
        0x53E   =&gt; array(0x56E),
        0x53F   =&gt; array(0x56F),
        0x540   =&gt; array(0x570),
        0x541   =&gt; array(0x571),
        0x542   =&gt; array(0x572),
        0x543   =&gt; array(0x573),
        0x544   =&gt; array(0x574),
        0x545   =&gt; array(0x575),
        0x546   =&gt; array(0x576),
        0x547   =&gt; array(0x577),
        0x548   =&gt; array(0x578),
        0x549   =&gt; array(0x579),
        0x54A   =&gt; array(0x57A),
        0x54B   =&gt; array(0x57B),
        0x54C   =&gt; array(0x57C),
        0x54D   =&gt; array(0x57D),
        0x54E   =&gt; array(0x57E),
        0x54F   =&gt; array(0x57F),
        0x550   =&gt; array(0x580),
        0x551   =&gt; array(0x581),
        0x552   =&gt; array(0x582),
        0x553   =&gt; array(0x583),
        0x554   =&gt; array(0x584),
        0x555   =&gt; array(0x585),
        0x556   =&gt; array(0x586),
        0x587   =&gt; array(0x565, 0x582),
        0x1E00  =&gt; array(0x1E01),
        0x1E02  =&gt; array(0x1E03),
        0x1E04  =&gt; array(0x1E05),
        0x1E06  =&gt; array(0x1E07),
        0x1E08  =&gt; array(0x1E09),
        0x1E0A  =&gt; array(0x1E0B),
        0x1E0C  =&gt; array(0x1E0D),
        0x1E0E  =&gt; array(0x1E0F),
        0x1E10  =&gt; array(0x1E11),
        0x1E12  =&gt; array(0x1E13),
        0x1E14  =&gt; array(0x1E15),
        0x1E16  =&gt; array(0x1E17),
        0x1E18  =&gt; array(0x1E19),
        0x1E1A  =&gt; array(0x1E1B),
        0x1E1C  =&gt; array(0x1E1D),
        0x1E1E  =&gt; array(0x1E1F),
        0x1E20  =&gt; array(0x1E21),
        0x1E22  =&gt; array(0x1E23),
        0x1E24  =&gt; array(0x1E25),
        0x1E26  =&gt; array(0x1E27),
        0x1E28  =&gt; array(0x1E29),
        0x1E2A  =&gt; array(0x1E2B),
        0x1E2C  =&gt; array(0x1E2D),
        0x1E2E  =&gt; array(0x1E2F),
        0x1E30  =&gt; array(0x1E31),
        0x1E32  =&gt; array(0x1E33),
        0x1E34  =&gt; array(0x1E35),
        0x1E36  =&gt; array(0x1E37),
        0x1E38  =&gt; array(0x1E39),
        0x1E3A  =&gt; array(0x1E3B),
        0x1E3C  =&gt; array(0x1E3D),
        0x1E3E  =&gt; array(0x1E3F),
        0x1E40  =&gt; array(0x1E41),
        0x1E42  =&gt; array(0x1E43),
        0x1E44  =&gt; array(0x1E45),
        0x1E46  =&gt; array(0x1E47),
        0x1E48  =&gt; array(0x1E49),
        0x1E4A  =&gt; array(0x1E4B),
        0x1E4C  =&gt; array(0x1E4D),
        0x1E4E  =&gt; array(0x1E4F),
        0x1E50  =&gt; array(0x1E51),
        0x1E52  =&gt; array(0x1E53),
        0x1E54  =&gt; array(0x1E55),
        0x1E56  =&gt; array(0x1E57),
        0x1E58  =&gt; array(0x1E59),
        0x1E5A  =&gt; array(0x1E5B),
        0x1E5C  =&gt; array(0x1E5D),
        0x1E5E  =&gt; array(0x1E5F),
        0x1E60  =&gt; array(0x1E61),
        0x1E62  =&gt; array(0x1E63),
        0x1E64  =&gt; array(0x1E65),
        0x1E66  =&gt; array(0x1E67),
        0x1E68  =&gt; array(0x1E69),
        0x1E6A  =&gt; array(0x1E6B),
        0x1E6C  =&gt; array(0x1E6D),
        0x1E6E  =&gt; array(0x1E6F),
        0x1E70  =&gt; array(0x1E71),
        0x1E72  =&gt; array(0x1E73),
        0x1E74  =&gt; array(0x1E75),
        0x1E76  =&gt; array(0x1E77),
        0x1E78  =&gt; array(0x1E79),
        0x1E7A  =&gt; array(0x1E7B),
        0x1E7C  =&gt; array(0x1E7D),
        0x1E7E  =&gt; array(0x1E7F),
        0x1E80  =&gt; array(0x1E81),
        0x1E82  =&gt; array(0x1E83),
        0x1E84  =&gt; array(0x1E85),
        0x1E86  =&gt; array(0x1E87),
        0x1E88  =&gt; array(0x1E89),
        0x1E8A  =&gt; array(0x1E8B),
        0x1E8C  =&gt; array(0x1E8D),
        0x1E8E  =&gt; array(0x1E8F),
        0x1E90  =&gt; array(0x1E91),
        0x1E92  =&gt; array(0x1E93),
        0x1E94  =&gt; array(0x1E95),
        0x1E96  =&gt; array(0x68, 0x331),
        0x1E97  =&gt; array(0x74, 0x308),
        0x1E98  =&gt; array(0x77, 0x30A),
        0x1E99  =&gt; array(0x79, 0x30A),
        0x1E9A  =&gt; array(0x61, 0x2BE),
        0x1E9B  =&gt; array(0x1E61),
        0x1EA0  =&gt; array(0x1EA1),
        0x1EA2  =&gt; array(0x1EA3),
        0x1EA4  =&gt; array(0x1EA5),
        0x1EA6  =&gt; array(0x1EA7),
        0x1EA8  =&gt; array(0x1EA9),
        0x1EAA  =&gt; array(0x1EAB),
        0x1EAC  =&gt; array(0x1EAD),
        0x1EAE  =&gt; array(0x1EAF),
        0x1EB0  =&gt; array(0x1EB1),
        0x1EB2  =&gt; array(0x1EB3),
        0x1EB4  =&gt; array(0x1EB5),
        0x1EB6  =&gt; array(0x1EB7),
        0x1EB8  =&gt; array(0x1EB9),
        0x1EBA  =&gt; array(0x1EBB),
        0x1EBC  =&gt; array(0x1EBD),
        0x1EBE  =&gt; array(0x1EBF),
        0x1EC0  =&gt; array(0x1EC1),
        0x1EC2  =&gt; array(0x1EC3),
        0x1EC4  =&gt; array(0x1EC5),
        0x1EC6  =&gt; array(0x1EC7),
        0x1EC8  =&gt; array(0x1EC9),
        0x1ECA  =&gt; array(0x1ECB),
        0x1ECC  =&gt; array(0x1ECD),
        0x1ECE  =&gt; array(0x1ECF),
        0x1ED0  =&gt; array(0x1ED1),
        0x1ED2  =&gt; array(0x1ED3),
        0x1ED4  =&gt; array(0x1ED5),
        0x1ED6  =&gt; array(0x1ED7),
        0x1ED8  =&gt; array(0x1ED9),
        0x1EDA  =&gt; array(0x1EDB),
        0x1EDC  =&gt; array(0x1EDD),
        0x1EDE  =&gt; array(0x1EDF),
        0x1EE0  =&gt; array(0x1EE1),
        0x1EE2  =&gt; array(0x1EE3),
        0x1EE4  =&gt; array(0x1EE5),
        0x1EE6  =&gt; array(0x1EE7),
        0x1EE8  =&gt; array(0x1EE9),
        0x1EEA  =&gt; array(0x1EEB),
        0x1EEC  =&gt; array(0x1EED),
        0x1EEE  =&gt; array(0x1EEF),
        0x1EF0  =&gt; array(0x1EF1),
        0x1EF2  =&gt; array(0x1EF3),
        0x1EF4  =&gt; array(0x1EF5),
        0x1EF6  =&gt; array(0x1EF7),
        0x1EF8  =&gt; array(0x1EF9),
        0x1F08  =&gt; array(0x1F00),
        0x1F09  =&gt; array(0x1F01),
        0x1F0A  =&gt; array(0x1F02),
        0x1F0B  =&gt; array(0x1F03),
        0x1F0C  =&gt; array(0x1F04),
        0x1F0D  =&gt; array(0x1F05),
        0x1F0E  =&gt; array(0x1F06),
        0x1F0F  =&gt; array(0x1F07),
        0x1F18  =&gt; array(0x1F10),
        0x1F19  =&gt; array(0x1F11),
        0x1F1A  =&gt; array(0x1F12),
        0x1F1B  =&gt; array(0x1F13),
        0x1F1C  =&gt; array(0x1F14),
        0x1F1D  =&gt; array(0x1F15),
        0x1F28  =&gt; array(0x1F20),
        0x1F29  =&gt; array(0x1F21),
        0x1F2A  =&gt; array(0x1F22),
        0x1F2B  =&gt; array(0x1F23),
        0x1F2C  =&gt; array(0x1F24),
        0x1F2D  =&gt; array(0x1F25),
        0x1F2E  =&gt; array(0x1F26),
        0x1F2F  =&gt; array(0x1F27),
        0x1F38  =&gt; array(0x1F30),
        0x1F39  =&gt; array(0x1F31),
        0x1F3A  =&gt; array(0x1F32),
        0x1F3B  =&gt; array(0x1F33),
        0x1F3C  =&gt; array(0x1F34),
        0x1F3D  =&gt; array(0x1F35),
        0x1F3E  =&gt; array(0x1F36),
        0x1F3F  =&gt; array(0x1F37),
        0x1F48  =&gt; array(0x1F40),
        0x1F49  =&gt; array(0x1F41),
        0x1F4A  =&gt; array(0x1F42),
        0x1F4B  =&gt; array(0x1F43),
        0x1F4C  =&gt; array(0x1F44),
        0x1F4D  =&gt; array(0x1F45),
        0x1F50  =&gt; array(0x3C5, 0x313),
        0x1F52  =&gt; array(0x3C5, 0x313, 0x300),
        0x1F54  =&gt; array(0x3C5, 0x313, 0x301),
        0x1F56  =&gt; array(0x3C5, 0x313, 0x342),
        0x1F59  =&gt; array(0x1F51),
        0x1F5B  =&gt; array(0x1F53),
        0x1F5D  =&gt; array(0x1F55),
        0x1F5F  =&gt; array(0x1F57),
        0x1F68  =&gt; array(0x1F60),
        0x1F69  =&gt; array(0x1F61),
        0x1F6A  =&gt; array(0x1F62),
        0x1F6B  =&gt; array(0x1F63),
        0x1F6C  =&gt; array(0x1F64),
        0x1F6D  =&gt; array(0x1F65),
        0x1F6E  =&gt; array(0x1F66),
        0x1F6F  =&gt; array(0x1F67),
        0x1F80  =&gt; array(0x1F00, 0x3B9),
        0x1F81  =&gt; array(0x1F01, 0x3B9),
        0x1F82  =&gt; array(0x1F02, 0x3B9),
        0x1F83  =&gt; array(0x1F03, 0x3B9),
        0x1F84  =&gt; array(0x1F04, 0x3B9),
        0x1F85  =&gt; array(0x1F05, 0x3B9),
        0x1F86  =&gt; array(0x1F06, 0x3B9),
        0x1F87  =&gt; array(0x1F07, 0x3B9),
        0x1F88  =&gt; array(0x1F00, 0x3B9),
        0x1F89  =&gt; array(0x1F01, 0x3B9),
        0x1F8A  =&gt; array(0x1F02, 0x3B9),
        0x1F8B  =&gt; array(0x1F03, 0x3B9),
        0x1F8C  =&gt; array(0x1F04, 0x3B9),
        0x1F8D  =&gt; array(0x1F05, 0x3B9),
        0x1F8E  =&gt; array(0x1F06, 0x3B9),
        0x1F8F  =&gt; array(0x1F07, 0x3B9),
        0x1F90  =&gt; array(0x1F20, 0x3B9),
        0x1F91  =&gt; array(0x1F21, 0x3B9),
        0x1F92  =&gt; array(0x1F22, 0x3B9),
        0x1F93  =&gt; array(0x1F23, 0x3B9),
        0x1F94  =&gt; array(0x1F24, 0x3B9),
        0x1F95  =&gt; array(0x1F25, 0x3B9),
        0x1F96  =&gt; array(0x1F26, 0x3B9),
        0x1F97  =&gt; array(0x1F27, 0x3B9),
        0x1F98  =&gt; array(0x1F20, 0x3B9),
        0x1F99  =&gt; array(0x1F21, 0x3B9),
        0x1F9A  =&gt; array(0x1F22, 0x3B9),
        0x1F9B  =&gt; array(0x1F23, 0x3B9),
        0x1F9C  =&gt; array(0x1F24, 0x3B9),
        0x1F9D  =&gt; array(0x1F25, 0x3B9),
        0x1F9E  =&gt; array(0x1F26, 0x3B9),
        0x1F9F  =&gt; array(0x1F27, 0x3B9),
        0x1FA0  =&gt; array(0x1F60, 0x3B9),
        0x1FA1  =&gt; array(0x1F61, 0x3B9),
        0x1FA2  =&gt; array(0x1F62, 0x3B9),
        0x1FA3  =&gt; array(0x1F63, 0x3B9),
        0x1FA4  =&gt; array(0x1F64, 0x3B9),
        0x1FA5  =&gt; array(0x1F65, 0x3B9),
        0x1FA6  =&gt; array(0x1F66, 0x3B9),
        0x1FA7  =&gt; array(0x1F67, 0x3B9),
        0x1FA8  =&gt; array(0x1F60, 0x3B9),
        0x1FA9  =&gt; array(0x1F61, 0x3B9),
        0x1FAA  =&gt; array(0x1F62, 0x3B9),
        0x1FAB  =&gt; array(0x1F63, 0x3B9),
        0x1FAC  =&gt; array(0x1F64, 0x3B9),
        0x1FAD  =&gt; array(0x1F65, 0x3B9),
        0x1FAE  =&gt; array(0x1F66, 0x3B9),
        0x1FAF  =&gt; array(0x1F67, 0x3B9),
        0x1FB2  =&gt; array(0x1F70, 0x3B9),
        0x1FB3  =&gt; array(0x3B1, 0x3B9),
        0x1FB4  =&gt; array(0x3AC, 0x3B9),
        0x1FB6  =&gt; array(0x3B1, 0x342),
        0x1FB7  =&gt; array(0x3B1, 0x342, 0x3B9),
        0x1FB8  =&gt; array(0x1FB0),
        0x1FB9  =&gt; array(0x1FB1),
        0x1FBA  =&gt; array(0x1F70),
        0x1FBB  =&gt; array(0x1F71),
        0x1FBC  =&gt; array(0x3B1, 0x3B9),
        0x1FBE  =&gt; array(0x3B9),
        0x1FC2  =&gt; array(0x1F74, 0x3B9),
        0x1FC3  =&gt; array(0x3B7, 0x3B9),
        0x1FC4  =&gt; array(0x3AE, 0x3B9),
        0x1FC6  =&gt; array(0x3B7, 0x342),
        0x1FC7  =&gt; array(0x3B7, 0x342, 0x3B9),
        0x1FC8  =&gt; array(0x1F72),
        0x1FC9  =&gt; array(0x1F73),
        0x1FCA  =&gt; array(0x1F74),
        0x1FCB  =&gt; array(0x1F75),
        0x1FCC  =&gt; array(0x3B7, 0x3B9),
        0x1FD2  =&gt; array(0x3B9, 0x308, 0x300),
        0x1FD3  =&gt; array(0x3B9, 0x308, 0x301),
        0x1FD6  =&gt; array(0x3B9, 0x342),
        0x1FD7  =&gt; array(0x3B9, 0x308, 0x342),
        0x1FD8  =&gt; array(0x1FD0),
        0x1FD9  =&gt; array(0x1FD1),
        0x1FDA  =&gt; array(0x1F76),
        0x1FDB  =&gt; array(0x1F77),
        0x1FE2  =&gt; array(0x3C5, 0x308, 0x300),
        0x1FE3  =&gt; array(0x3C5, 0x308, 0x301),
        0x1FE4  =&gt; array(0x3C1, 0x313),
        0x1FE6  =&gt; array(0x3C5, 0x342),
        0x1FE7  =&gt; array(0x3C5, 0x308, 0x342),
        0x1FE8  =&gt; array(0x1FE0),
        0x1FE9  =&gt; array(0x1FE1),
        0x1FEA  =&gt; array(0x1F7A),
        0x1FEB  =&gt; array(0x1F7B),
        0x1FEC  =&gt; array(0x1FE5),
        0x1FF2  =&gt; array(0x1F7C, 0x3B9),
        0x1FF3  =&gt; array(0x3C9, 0x3B9),
        0x1FF4  =&gt; array(0x3CE, 0x3B9),
        0x1FF6  =&gt; array(0x3C9, 0x342),
        0x1FF7  =&gt; array(0x3C9, 0x342, 0x3B9),
        0x1FF8  =&gt; array(0x1F78),
        0x1FF9  =&gt; array(0x1F79),
        0x1FFA  =&gt; array(0x1F7C),
        0x1FFB  =&gt; array(0x1F7D),
        0x1FFC  =&gt; array(0x3C9, 0x3B9),
        0x20A8  =&gt; array(0x72, 0x73),
        0x2102  =&gt; array(0x63),
        0x2103  =&gt; array(0xB0, 0x63),
        0x2107  =&gt; array(0x25B),
        0x2109  =&gt; array(0xB0, 0x66),
        0x210B  =&gt; array(0x68),
        0x210C  =&gt; array(0x68),
        0x210D  =&gt; array(0x68),
        0x2110  =&gt; array(0x69),
        0x2111  =&gt; array(0x69),
        0x2112  =&gt; array(0x6C),
        0x2115  =&gt; array(0x6E),
        0x2116  =&gt; array(0x6E, 0x6F),
        0x2119  =&gt; array(0x70),
        0x211A  =&gt; array(0x71),
        0x211B  =&gt; array(0x72),
        0x211C  =&gt; array(0x72),
        0x211D  =&gt; array(0x72),
        0x2120  =&gt; array(0x73, 0x6D),
        0x2121  =&gt; array(0x74, 0x65, 0x6C),
        0x2122  =&gt; array(0x74, 0x6D),
        0x2124  =&gt; array(0x7A),
        0x2126  =&gt; array(0x3C9),
        0x2128  =&gt; array(0x7A),
        0x212A  =&gt; array(0x6B),
        0x212B  =&gt; array(0xE5),
        0x212C  =&gt; array(0x62),
        0x212D  =&gt; array(0x63),
        0x2130  =&gt; array(0x65),
        0x2131  =&gt; array(0x66),
        0x2133  =&gt; array(0x6D),
        0x213E  =&gt; array(0x3B3),
        0x213F  =&gt; array(0x3C0),
        0x2145  =&gt; array(0x64),
        0x2160  =&gt; array(0x2170),
        0x2161  =&gt; array(0x2171),
        0x2162  =&gt; array(0x2172),
        0x2163  =&gt; array(0x2173),
        0x2164  =&gt; array(0x2174),
        0x2165  =&gt; array(0x2175),
        0x2166  =&gt; array(0x2176),
        0x2167  =&gt; array(0x2177),
        0x2168  =&gt; array(0x2178),
        0x2169  =&gt; array(0x2179),
        0x216A  =&gt; array(0x217A),
        0x216B  =&gt; array(0x217B),
        0x216C  =&gt; array(0x217C),
        0x216D  =&gt; array(0x217D),
        0x216E  =&gt; array(0x217E),
        0x216F  =&gt; array(0x217F),
        0x24B6  =&gt; array(0x24D0),
        0x24B7  =&gt; array(0x24D1),
        0x24B8  =&gt; array(0x24D2),
        0x24B9  =&gt; array(0x24D3),
        0x24BA  =&gt; array(0x24D4),
        0x24BB  =&gt; array(0x24D5),
        0x24BC  =&gt; array(0x24D6),
        0x24BD  =&gt; array(0x24D7),
        0x24BE  =&gt; array(0x24D8),
        0x24BF  =&gt; array(0x24D9),
        0x24C0  =&gt; array(0x24DA),
        0x24C1  =&gt; array(0x24DB),
        0x24C2  =&gt; array(0x24DC),
        0x24C3  =&gt; array(0x24DD),
        0x24C4  =&gt; array(0x24DE),
        0x24C5  =&gt; array(0x24DF),
        0x24C6  =&gt; array(0x24E0),
        0x24C7  =&gt; array(0x24E1),
        0x24C8  =&gt; array(0x24E2),
        0x24C9  =&gt; array(0x24E3),
        0x24CA  =&gt; array(0x24E4),
        0x24CB  =&gt; array(0x24E5),
        0x24CC  =&gt; array(0x24E6),
        0x24CD  =&gt; array(0x24E7),
        0x24CE  =&gt; array(0x24E8),
        0x24CF  =&gt; array(0x24E9),
        0x3371  =&gt; array(0x68, 0x70, 0x61),
        0x3373  =&gt; array(0x61, 0x75),
        0x3375  =&gt; array(0x6F, 0x76),
        0x3380  =&gt; array(0x70, 0x61),
        0x3381  =&gt; array(0x6E, 0x61),
        0x3382  =&gt; array(0x3BC, 0x61),
        0x3383  =&gt; array(0x6D, 0x61),
        0x3384  =&gt; array(0x6B, 0x61),
        0x3385  =&gt; array(0x6B, 0x62),
        0x3386  =&gt; array(0x6D, 0x62),
        0x3387  =&gt; array(0x67, 0x62),
        0x338A  =&gt; array(0x70, 0x66),
        0x338B  =&gt; array(0x6E, 0x66),
        0x338C  =&gt; array(0x3BC, 0x66),
        0x3390  =&gt; array(0x68, 0x7A),
        0x3391  =&gt; array(0x6B, 0x68, 0x7A),
        0x3392  =&gt; array(0x6D, 0x68, 0x7A),
        0x3393  =&gt; array(0x67, 0x68, 0x7A),
        0x3394  =&gt; array(0x74, 0x68, 0x7A),
        0x33A9  =&gt; array(0x70, 0x61),
        0x33AA  =&gt; array(0x6B, 0x70, 0x61),
        0x33AB  =&gt; array(0x6D, 0x70, 0x61),
        0x33AC  =&gt; array(0x67, 0x70, 0x61),
        0x33B4  =&gt; array(0x70, 0x76),
        0x33B5  =&gt; array(0x6E, 0x76),
        0x33B6  =&gt; array(0x3BC, 0x76),
        0x33B7  =&gt; array(0x6D, 0x76),
        0x33B8  =&gt; array(0x6B, 0x76),
        0x33B9  =&gt; array(0x6D, 0x76),
        0x33BA  =&gt; array(0x70, 0x77),
        0x33BB  =&gt; array(0x6E, 0x77),
        0x33BC  =&gt; array(0x3BC, 0x77),
        0x33BD  =&gt; array(0x6D, 0x77),
        0x33BE  =&gt; array(0x6B, 0x77),
        0x33BF  =&gt; array(0x6D, 0x77),
        0x33C0  =&gt; array(0x6B, 0x3C9),
        0x33C1  =&gt; array(0x6D, 0x3C9),
        /* 0x33C2  =&gt; array(0x61, 0x2E, 0x6D, 0x2E), */
        0x33C3  =&gt; array(0x62, 0x71),
        0x33C6  =&gt; array(0x63, 0x2215, 0x6B, 0x67),
        0x33C7  =&gt; array(0x63, 0x6F, 0x2E),
        0x33C8  =&gt; array(0x64, 0x62),
        0x33C9  =&gt; array(0x67, 0x79),
        0x33CB  =&gt; array(0x68, 0x70),
        0x33CD  =&gt; array(0x6B, 0x6B),
        0x33CE  =&gt; array(0x6B, 0x6D),
        0x33D7  =&gt; array(0x70, 0x68),
        0x33D9  =&gt; array(0x70, 0x70, 0x6D),
        0x33DA  =&gt; array(0x70, 0x72),
        0x33DC  =&gt; array(0x73, 0x76),
        0x33DD  =&gt; array(0x77, 0x62),
        0xFB00  =&gt; array(0x66, 0x66),
        0xFB01  =&gt; array(0x66, 0x69),
        0xFB02  =&gt; array(0x66, 0x6C),
        0xFB03  =&gt; array(0x66, 0x66, 0x69),
        0xFB04  =&gt; array(0x66, 0x66, 0x6C),
        0xFB05  =&gt; array(0x73, 0x74),
        0xFB06  =&gt; array(0x73, 0x74),
        0xFB13  =&gt; array(0x574, 0x576),
        0xFB14  =&gt; array(0x574, 0x565),
        0xFB15  =&gt; array(0x574, 0x56B),
        0xFB16  =&gt; array(0x57E, 0x576),
        0xFB17  =&gt; array(0x574, 0x56D),
        0xFF21  =&gt; array(0xFF41),
        0xFF22  =&gt; array(0xFF42),
        0xFF23  =&gt; array(0xFF43),
        0xFF24  =&gt; array(0xFF44),
        0xFF25  =&gt; array(0xFF45),
        0xFF26  =&gt; array(0xFF46),
        0xFF27  =&gt; array(0xFF47),
        0xFF28  =&gt; array(0xFF48),
        0xFF29  =&gt; array(0xFF49),
        0xFF2A  =&gt; array(0xFF4A),
        0xFF2B  =&gt; array(0xFF4B),
        0xFF2C  =&gt; array(0xFF4C),
        0xFF2D  =&gt; array(0xFF4D),
        0xFF2E  =&gt; array(0xFF4E),
        0xFF2F  =&gt; array(0xFF4F),
        0xFF30  =&gt; array(0xFF50),
        0xFF31  =&gt; array(0xFF51),
        0xFF32  =&gt; array(0xFF52),
        0xFF33  =&gt; array(0xFF53),
        0xFF34  =&gt; array(0xFF54),
        0xFF35  =&gt; array(0xFF55),
        0xFF36  =&gt; array(0xFF56),
        0xFF37  =&gt; array(0xFF57),
        0xFF38  =&gt; array(0xFF58),
        0xFF39  =&gt; array(0xFF59),
        0xFF3A  =&gt; array(0xFF5A),
        0x10400 =&gt; array(0x10428),
        0x10401 =&gt; array(0x10429),
        0x10402 =&gt; array(0x1042A),
        0x10403 =&gt; array(0x1042B),
        0x10404 =&gt; array(0x1042C),
        0x10405 =&gt; array(0x1042D),
        0x10406 =&gt; array(0x1042E),
        0x10407 =&gt; array(0x1042F),
        0x10408 =&gt; array(0x10430),
        0x10409 =&gt; array(0x10431),
        0x1040A =&gt; array(0x10432),
        0x1040B =&gt; array(0x10433),
        0x1040C =&gt; array(0x10434),
        0x1040D =&gt; array(0x10435),
        0x1040E =&gt; array(0x10436),
        0x1040F =&gt; array(0x10437),
        0x10410 =&gt; array(0x10438),
        0x10411 =&gt; array(0x10439),
        0x10412 =&gt; array(0x1043A),
        0x10413 =&gt; array(0x1043B),
        0x10414 =&gt; array(0x1043C),
        0x10415 =&gt; array(0x1043D),
        0x10416 =&gt; array(0x1043E),
        0x10417 =&gt; array(0x1043F),
        0x10418 =&gt; array(0x10440),
        0x10419 =&gt; array(0x10441),
        0x1041A =&gt; array(0x10442),
        0x1041B =&gt; array(0x10443),
        0x1041C =&gt; array(0x10444),
        0x1041D =&gt; array(0x10445),
        0x1041E =&gt; array(0x10446),
        0x1041F =&gt; array(0x10447),
        0x10420 =&gt; array(0x10448),
        0x10421 =&gt; array(0x10449),
        0x10422 =&gt; array(0x1044A),
        0x10423 =&gt; array(0x1044B),
        0x10424 =&gt; array(0x1044C),
        0x10425 =&gt; array(0x1044D),
        0x1D400 =&gt; array(0x61),
        0x1D401 =&gt; array(0x62),
        0x1D402 =&gt; array(0x63),
        0x1D403 =&gt; array(0x64),
        0x1D404 =&gt; array(0x65),
        0x1D405 =&gt; array(0x66),
        0x1D406 =&gt; array(0x67),
        0x1D407 =&gt; array(0x68),
        0x1D408 =&gt; array(0x69),
        0x1D409 =&gt; array(0x6A),
        0x1D40A =&gt; array(0x6B),
        0x1D40B =&gt; array(0x6C),
        0x1D40C =&gt; array(0x6D),
        0x1D40D =&gt; array(0x6E),
        0x1D40E =&gt; array(0x6F),
        0x1D40F =&gt; array(0x70),
        0x1D410 =&gt; array(0x71),
        0x1D411 =&gt; array(0x72),
        0x1D412 =&gt; array(0x73),
        0x1D413 =&gt; array(0x74),
        0x1D414 =&gt; array(0x75),
        0x1D415 =&gt; array(0x76),
        0x1D416 =&gt; array(0x77),
        0x1D417 =&gt; array(0x78),
        0x1D418 =&gt; array(0x79),
        0x1D419 =&gt; array(0x7A),
        0x1D434 =&gt; array(0x61),
        0x1D435 =&gt; array(0x62),
        0x1D436 =&gt; array(0x63),
        0x1D437 =&gt; array(0x64),
        0x1D438 =&gt; array(0x65),
        0x1D439 =&gt; array(0x66),
        0x1D43A =&gt; array(0x67),
        0x1D43B =&gt; array(0x68),
        0x1D43C =&gt; array(0x69),
        0x1D43D =&gt; array(0x6A),
        0x1D43E =&gt; array(0x6B),
        0x1D43F =&gt; array(0x6C),
        0x1D440 =&gt; array(0x6D),
        0x1D441 =&gt; array(0x6E),
        0x1D442 =&gt; array(0x6F),
        0x1D443 =&gt; array(0x70),
        0x1D444 =&gt; array(0x71),
        0x1D445 =&gt; array(0x72),
        0x1D446 =&gt; array(0x73),
        0x1D447 =&gt; array(0x74),
        0x1D448 =&gt; array(0x75),
        0x1D449 =&gt; array(0x76),
        0x1D44A =&gt; array(0x77),
        0x1D44B =&gt; array(0x78),
        0x1D44C =&gt; array(0x79),
        0x1D44D =&gt; array(0x7A),
        0x1D468 =&gt; array(0x61),
        0x1D469 =&gt; array(0x62),
        0x1D46A =&gt; array(0x63),
        0x1D46B =&gt; array(0x64),
        0x1D46C =&gt; array(0x65),
        0x1D46D =&gt; array(0x66),
        0x1D46E =&gt; array(0x67),
        0x1D46F =&gt; array(0x68),
        0x1D470 =&gt; array(0x69),
        0x1D471 =&gt; array(0x6A),
        0x1D472 =&gt; array(0x6B),
        0x1D473 =&gt; array(0x6C),
        0x1D474 =&gt; array(0x6D),
        0x1D475 =&gt; array(0x6E),
        0x1D476 =&gt; array(0x6F),
        0x1D477 =&gt; array(0x70),
        0x1D478 =&gt; array(0x71),
        0x1D479 =&gt; array(0x72),
        0x1D47A =&gt; array(0x73),
        0x1D47B =&gt; array(0x74),
        0x1D47C =&gt; array(0x75),
        0x1D47D =&gt; array(0x76),
        0x1D47E =&gt; array(0x77),
        0x1D47F =&gt; array(0x78),
        0x1D480 =&gt; array(0x79),
        0x1D481 =&gt; array(0x7A),
        0x1D49C =&gt; array(0x61),
        0x1D49E =&gt; array(0x63),
        0x1D49F =&gt; array(0x64),
        0x1D4A2 =&gt; array(0x67),
        0x1D4A5 =&gt; array(0x6A),
        0x1D4A6 =&gt; array(0x6B),
        0x1D4A9 =&gt; array(0x6E),
        0x1D4AA =&gt; array(0x6F),
        0x1D4AB =&gt; array(0x70),
        0x1D4AC =&gt; array(0x71),
        0x1D4AE =&gt; array(0x73),
        0x1D4AF =&gt; array(0x74),
        0x1D4B0 =&gt; array(0x75),
        0x1D4B1 =&gt; array(0x76),
        0x1D4B2 =&gt; array(0x77),
        0x1D4B3 =&gt; array(0x78),
        0x1D4B4 =&gt; array(0x79),
        0x1D4B5 =&gt; array(0x7A),
        0x1D4D0 =&gt; array(0x61),
        0x1D4D1 =&gt; array(0x62),
        0x1D4D2 =&gt; array(0x63),
        0x1D4D3 =&gt; array(0x64),
        0x1D4D4 =&gt; array(0x65),
        0x1D4D5 =&gt; array(0x66),
        0x1D4D6 =&gt; array(0x67),
        0x1D4D7 =&gt; array(0x68),
        0x1D4D8 =&gt; array(0x69),
        0x1D4D9 =&gt; array(0x6A),
        0x1D4DA =&gt; array(0x6B),
        0x1D4DB =&gt; array(0x6C),
        0x1D4DC =&gt; array(0x6D),
        0x1D4DD =&gt; array(0x6E),
        0x1D4DE =&gt; array(0x6F),
        0x1D4DF =&gt; array(0x70),
        0x1D4E0 =&gt; array(0x71),
        0x1D4E1 =&gt; array(0x72),
        0x1D4E2 =&gt; array(0x73),
        0x1D4E3 =&gt; array(0x74),
        0x1D4E4 =&gt; array(0x75),
        0x1D4E5 =&gt; array(0x76),
        0x1D4E6 =&gt; array(0x77),
        0x1D4E7 =&gt; array(0x78),
        0x1D4E8 =&gt; array(0x79),
        0x1D4E9 =&gt; array(0x7A),
        0x1D504 =&gt; array(0x61),
        0x1D505 =&gt; array(0x62),
        0x1D507 =&gt; array(0x64),
        0x1D508 =&gt; array(0x65),
        0x1D509 =&gt; array(0x66),
        0x1D50A =&gt; array(0x67),
        0x1D50D =&gt; array(0x6A),
        0x1D50E =&gt; array(0x6B),
        0x1D50F =&gt; array(0x6C),
        0x1D510 =&gt; array(0x6D),
        0x1D511 =&gt; array(0x6E),
        0x1D512 =&gt; array(0x6F),
        0x1D513 =&gt; array(0x70),
        0x1D514 =&gt; array(0x71),
        0x1D516 =&gt; array(0x73),
        0x1D517 =&gt; array(0x74),
        0x1D518 =&gt; array(0x75),
        0x1D519 =&gt; array(0x76),
        0x1D51A =&gt; array(0x77),
        0x1D51B =&gt; array(0x78),
        0x1D51C =&gt; array(0x79),
        0x1D538 =&gt; array(0x61),
        0x1D539 =&gt; array(0x62),
        0x1D53B =&gt; array(0x64),
        0x1D53C =&gt; array(0x65),
        0x1D53D =&gt; array(0x66),
        0x1D53E =&gt; array(0x67),
        0x1D540 =&gt; array(0x69),
        0x1D541 =&gt; array(0x6A),
        0x1D542 =&gt; array(0x6B),
        0x1D543 =&gt; array(0x6C),
        0x1D544 =&gt; array(0x6D),
        0x1D546 =&gt; array(0x6F),
        0x1D54A =&gt; array(0x73),
        0x1D54B =&gt; array(0x74),
        0x1D54C =&gt; array(0x75),
        0x1D54D =&gt; array(0x76),
        0x1D54E =&gt; array(0x77),
        0x1D54F =&gt; array(0x78),
        0x1D550 =&gt; array(0x79),
        0x1D56C =&gt; array(0x61),
        0x1D56D =&gt; array(0x62),
        0x1D56E =&gt; array(0x63),
        0x1D56F =&gt; array(0x64),
        0x1D570 =&gt; array(0x65),
        0x1D571 =&gt; array(0x66),
        0x1D572 =&gt; array(0x67),
        0x1D573 =&gt; array(0x68),
        0x1D574 =&gt; array(0x69),
        0x1D575 =&gt; array(0x6A),
        0x1D576 =&gt; array(0x6B),
        0x1D577 =&gt; array(0x6C),
        0x1D578 =&gt; array(0x6D),
        0x1D579 =&gt; array(0x6E),
        0x1D57A =&gt; array(0x6F),
        0x1D57B =&gt; array(0x70),
        0x1D57C =&gt; array(0x71),
        0x1D57D =&gt; array(0x72),
        0x1D57E =&gt; array(0x73),
        0x1D57F =&gt; array(0x74),
        0x1D580 =&gt; array(0x75),
        0x1D581 =&gt; array(0x76),
        0x1D582 =&gt; array(0x77),
        0x1D583 =&gt; array(0x78),
        0x1D584 =&gt; array(0x79),
        0x1D585 =&gt; array(0x7A),
        0x1D5A0 =&gt; array(0x61),
        0x1D5A1 =&gt; array(0x62),
        0x1D5A2 =&gt; array(0x63),
        0x1D5A3 =&gt; array(0x64),
        0x1D5A4 =&gt; array(0x65),
        0x1D5A5 =&gt; array(0x66),
        0x1D5A6 =&gt; array(0x67),
        0x1D5A7 =&gt; array(0x68),
        0x1D5A8 =&gt; array(0x69),
        0x1D5A9 =&gt; array(0x6A),
        0x1D5AA =&gt; array(0x6B),
        0x1D5AB =&gt; array(0x6C),
        0x1D5AC =&gt; array(0x6D),
        0x1D5AD =&gt; array(0x6E),
        0x1D5AE =&gt; array(0x6F),
        0x1D5AF =&gt; array(0x70),
        0x1D5B0 =&gt; array(0x71),
        0x1D5B1 =&gt; array(0x72),
        0x1D5B2 =&gt; array(0x73),
        0x1D5B3 =&gt; array(0x74),
        0x1D5B4 =&gt; array(0x75),
        0x1D5B5 =&gt; array(0x76),
        0x1D5B6 =&gt; array(0x77),
        0x1D5B7 =&gt; array(0x78),
        0x1D5B8 =&gt; array(0x79),
        0x1D5B9 =&gt; array(0x7A),
        0x1D5D4 =&gt; array(0x61),
        0x1D5D5 =&gt; array(0x62),
        0x1D5D6 =&gt; array(0x63),
        0x1D5D7 =&gt; array(0x64),
        0x1D5D8 =&gt; array(0x65),
        0x1D5D9 =&gt; array(0x66),
        0x1D5DA =&gt; array(0x67),
        0x1D5DB =&gt; array(0x68),
        0x1D5DC =&gt; array(0x69),
        0x1D5DD =&gt; array(0x6A),
        0x1D5DE =&gt; array(0x6B),
        0x1D5DF =&gt; array(0x6C),
        0x1D5E0 =&gt; array(0x6D),
        0x1D5E1 =&gt; array(0x6E),
        0x1D5E2 =&gt; array(0x6F),
        0x1D5E3 =&gt; array(0x70),
        0x1D5E4 =&gt; array(0x71),
        0x1D5E5 =&gt; array(0x72),
        0x1D5E6 =&gt; array(0x73),
        0x1D5E7 =&gt; array(0x74),
        0x1D5E8 =&gt; array(0x75),
        0x1D5E9 =&gt; array(0x76),
        0x1D5EA =&gt; array(0x77),
        0x1D5EB =&gt; array(0x78),
        0x1D5EC =&gt; array(0x79),
        0x1D5ED =&gt; array(0x7A),
        0x1D608 =&gt; array(0x61),
        0x1D609 =&gt; array(0x62),
        0x1D60A =&gt; array(0x63),
        0x1D60B =&gt; array(0x64),
        0x1D60C =&gt; array(0x65),
        0x1D60D =&gt; array(0x66),
        0x1D60E =&gt; array(0x67),
        0x1D60F =&gt; array(0x68),
        0x1D610 =&gt; array(0x69),
        0x1D611 =&gt; array(0x6A),
        0x1D612 =&gt; array(0x6B),
        0x1D613 =&gt; array(0x6C),
        0x1D614 =&gt; array(0x6D),
        0x1D615 =&gt; array(0x6E),
        0x1D616 =&gt; array(0x6F),
        0x1D617 =&gt; array(0x70),
        0x1D618 =&gt; array(0x71),
        0x1D619 =&gt; array(0x72),
        0x1D61A =&gt; array(0x73),
        0x1D61B =&gt; array(0x74),
        0x1D61C =&gt; array(0x75),
        0x1D61D =&gt; array(0x76),
        0x1D61E =&gt; array(0x77),
        0x1D61F =&gt; array(0x78),
        0x1D620 =&gt; array(0x79),
        0x1D621 =&gt; array(0x7A),
        0x1D63C =&gt; array(0x61),
        0x1D63D =&gt; array(0x62),
        0x1D63E =&gt; array(0x63),
        0x1D63F =&gt; array(0x64),
        0x1D640 =&gt; array(0x65),
        0x1D641 =&gt; array(0x66),
        0x1D642 =&gt; array(0x67),
        0x1D643 =&gt; array(0x68),
        0x1D644 =&gt; array(0x69),
        0x1D645 =&gt; array(0x6A),
        0x1D646 =&gt; array(0x6B),
        0x1D647 =&gt; array(0x6C),
        0x1D648 =&gt; array(0x6D),
        0x1D649 =&gt; array(0x6E),
        0x1D64A =&gt; array(0x6F),
        0x1D64B =&gt; array(0x70),
        0x1D64C =&gt; array(0x71),
        0x1D64D =&gt; array(0x72),
        0x1D64E =&gt; array(0x73),
        0x1D64F =&gt; array(0x74),
        0x1D650 =&gt; array(0x75),
        0x1D651 =&gt; array(0x76),
        0x1D652 =&gt; array(0x77),
        0x1D653 =&gt; array(0x78),
        0x1D654 =&gt; array(0x79),
        0x1D655 =&gt; array(0x7A),
        0x1D670 =&gt; array(0x61),
        0x1D671 =&gt; array(0x62),
        0x1D672 =&gt; array(0x63),
        0x1D673 =&gt; array(0x64),
        0x1D674 =&gt; array(0x65),
        0x1D675 =&gt; array(0x66),
        0x1D676 =&gt; array(0x67),
        0x1D677 =&gt; array(0x68),
        0x1D678 =&gt; array(0x69),
        0x1D679 =&gt; array(0x6A),
        0x1D67A =&gt; array(0x6B),
        0x1D67B =&gt; array(0x6C),
        0x1D67C =&gt; array(0x6D),
        0x1D67D =&gt; array(0x6E),
        0x1D67E =&gt; array(0x6F),
        0x1D67F =&gt; array(0x70),
        0x1D680 =&gt; array(0x71),
        0x1D681 =&gt; array(0x72),
        0x1D682 =&gt; array(0x73),
        0x1D683 =&gt; array(0x74),
        0x1D684 =&gt; array(0x75),
        0x1D685 =&gt; array(0x76),
        0x1D686 =&gt; array(0x77),
        0x1D687 =&gt; array(0x78),
        0x1D688 =&gt; array(0x79),
        0x1D689 =&gt; array(0x7A),
        0x1D6A8 =&gt; array(0x3B1),
        0x1D6A9 =&gt; array(0x3B2),
        0x1D6AA =&gt; array(0x3B3),
        0x1D6AB =&gt; array(0x3B4),
        0x1D6AC =&gt; array(0x3B5),
        0x1D6AD =&gt; array(0x3B6),
        0x1D6AE =&gt; array(0x3B7),
        0x1D6AF =&gt; array(0x3B8),
        0x1D6B0 =&gt; array(0x3B9),
        0x1D6B1 =&gt; array(0x3BA),
        0x1D6B2 =&gt; array(0x3BB),
        0x1D6B3 =&gt; array(0x3BC),
        0x1D6B4 =&gt; array(0x3BD),
        0x1D6B5 =&gt; array(0x3BE),
        0x1D6B6 =&gt; array(0x3BF),
        0x1D6B7 =&gt; array(0x3C0),
        0x1D6B8 =&gt; array(0x3C1),
        0x1D6B9 =&gt; array(0x3B8),
        0x1D6BA =&gt; array(0x3C3),
        0x1D6BB =&gt; array(0x3C4),
        0x1D6BC =&gt; array(0x3C5),
        0x1D6BD =&gt; array(0x3C6),
        0x1D6BE =&gt; array(0x3C7),
        0x1D6BF =&gt; array(0x3C8),
        0x1D6C0 =&gt; array(0x3C9),
        0x1D6D3 =&gt; array(0x3C3),
        0x1D6E2 =&gt; array(0x3B1),
        0x1D6E3 =&gt; array(0x3B2),
        0x1D6E4 =&gt; array(0x3B3),
        0x1D6E5 =&gt; array(0x3B4),
        0x1D6E6 =&gt; array(0x3B5),
        0x1D6E7 =&gt; array(0x3B6),
        0x1D6E8 =&gt; array(0x3B7),
        0x1D6E9 =&gt; array(0x3B8),
        0x1D6EA =&gt; array(0x3B9),
        0x1D6EB =&gt; array(0x3BA),
        0x1D6EC =&gt; array(0x3BB),
        0x1D6ED =&gt; array(0x3BC),
        0x1D6EE =&gt; array(0x3BD),
        0x1D6EF =&gt; array(0x3BE),
        0x1D6F0 =&gt; array(0x3BF),
        0x1D6F1 =&gt; array(0x3C0),
        0x1D6F2 =&gt; array(0x3C1),
        0x1D6F3 =&gt; array(0x3B8),
        0x1D6F4 =&gt; array(0x3C3),
        0x1D6F5 =&gt; array(0x3C4),
        0x1D6F6 =&gt; array(0x3C5),
        0x1D6F7 =&gt; array(0x3C6),
        0x1D6F8 =&gt; array(0x3C7),
        0x1D6F9 =&gt; array(0x3C8),
        0x1D6FA =&gt; array(0x3C9),
        0x1D70D =&gt; array(0x3C3),
        0x1D71C =&gt; array(0x3B1),
        0x1D71D =&gt; array(0x3B2),
        0x1D71E =&gt; array(0x3B3),
        0x1D71F =&gt; array(0x3B4),
        0x1D720 =&gt; array(0x3B5),
        0x1D721 =&gt; array(0x3B6),
        0x1D722 =&gt; array(0x3B7),
        0x1D723 =&gt; array(0x3B8),
        0x1D724 =&gt; array(0x3B9),
        0x1D725 =&gt; array(0x3BA),
        0x1D726 =&gt; array(0x3BB),
        0x1D727 =&gt; array(0x3BC),
        0x1D728 =&gt; array(0x3BD),
        0x1D729 =&gt; array(0x3BE),
        0x1D72A =&gt; array(0x3BF),
        0x1D72B =&gt; array(0x3C0),
        0x1D72C =&gt; array(0x3C1),
        0x1D72D =&gt; array(0x3B8),
        0x1D72E =&gt; array(0x3C3),
        0x1D72F =&gt; array(0x3C4),
        0x1D730 =&gt; array(0x3C5),
        0x1D731 =&gt; array(0x3C6),
        0x1D732 =&gt; array(0x3C7),
        0x1D733 =&gt; array(0x3C8),
        0x1D734 =&gt; array(0x3C9),
        0x1D747 =&gt; array(0x3C3),
        0x1D756 =&gt; array(0x3B1),
        0x1D757 =&gt; array(0x3B2),
        0x1D758 =&gt; array(0x3B3),
        0x1D759 =&gt; array(0x3B4),
        0x1D75A =&gt; array(0x3B5),
        0x1D75B =&gt; array(0x3B6),
        0x1D75C =&gt; array(0x3B7),
        0x1D75D =&gt; array(0x3B8),
        0x1D75E =&gt; array(0x3B9),
        0x1D75F =&gt; array(0x3BA),
        0x1D760 =&gt; array(0x3BB),
        0x1D761 =&gt; array(0x3BC),
        0x1D762 =&gt; array(0x3BD),
        0x1D763 =&gt; array(0x3BE),
        0x1D764 =&gt; array(0x3BF),
        0x1D765 =&gt; array(0x3C0),
        0x1D766 =&gt; array(0x3C1),
        0x1D767 =&gt; array(0x3B8),
        0x1D768 =&gt; array(0x3C3),
        0x1D769 =&gt; array(0x3C4),
        0x1D76A =&gt; array(0x3C5),
        0x1D76B =&gt; array(0x3C6),
        0x1D76C =&gt; array(0x3C7),
        0x1D76D =&gt; array(0x3C8),
        0x1D76E =&gt; array(0x3C9),
        0x1D781 =&gt; array(0x3C3),
        0x1D790 =&gt; array(0x3B1),
        0x1D791 =&gt; array(0x3B2),
        0x1D792 =&gt; array(0x3B3),
        0x1D793 =&gt; array(0x3B4),
        0x1D794 =&gt; array(0x3B5),
        0x1D795 =&gt; array(0x3B6),
        0x1D796 =&gt; array(0x3B7),
        0x1D797 =&gt; array(0x3B8),
        0x1D798 =&gt; array(0x3B9),
        0x1D799 =&gt; array(0x3BA),
        0x1D79A =&gt; array(0x3BB),
        0x1D79B =&gt; array(0x3BC),
        0x1D79C =&gt; array(0x3BD),
        0x1D79D =&gt; array(0x3BE),
        0x1D79E =&gt; array(0x3BF),
        0x1D79F =&gt; array(0x3C0),
        0x1D7A0 =&gt; array(0x3C1),
        0x1D7A1 =&gt; array(0x3B8),
        0x1D7A2 =&gt; array(0x3C3),
        0x1D7A3 =&gt; array(0x3C4),
        0x1D7A4 =&gt; array(0x3C5),
        0x1D7A5 =&gt; array(0x3C6),
        0x1D7A6 =&gt; array(0x3C7),
        0x1D7A7 =&gt; array(0x3C8),
        0x1D7A8 =&gt; array(0x3C9),
        0x1D7BB =&gt; array(0x3C3),
        0x3F9   =&gt; array(0x3C3),
        0x1D2C  =&gt; array(0x61),
        0x1D2D  =&gt; array(0xE6),
        0x1D2E  =&gt; array(0x62),
        0x1D30  =&gt; array(0x64),
        0x1D31  =&gt; array(0x65),
        0x1D32  =&gt; array(0x1DD),
        0x1D33  =&gt; array(0x67),
        0x1D34  =&gt; array(0x68),
        0x1D35  =&gt; array(0x69),
        0x1D36  =&gt; array(0x6A),
        0x1D37  =&gt; array(0x6B),
        0x1D38  =&gt; array(0x6C),
        0x1D39  =&gt; array(0x6D),
        0x1D3A  =&gt; array(0x6E),
        0x1D3C  =&gt; array(0x6F),
        0x1D3D  =&gt; array(0x223),
        0x1D3E  =&gt; array(0x70),
        0x1D3F  =&gt; array(0x72),
        0x1D40  =&gt; array(0x74),
        0x1D41  =&gt; array(0x75),
        0x1D42  =&gt; array(0x77),
        0x213B  =&gt; array(0x66, 0x61, 0x78),
        0x3250  =&gt; array(0x70, 0x74, 0x65),
        0x32CC  =&gt; array(0x68, 0x67),
        0x32CE  =&gt; array(0x65, 0x76),
        0x32CF  =&gt; array(0x6C, 0x74, 0x64),
        0x337A  =&gt; array(0x69, 0x75),
        0x33DE  =&gt; array(0x76, 0x2215, 0x6D),
        0x33DF  =&gt; array(0x61, 0x2215, 0x6D)
    );

    /**
     * Normalization Combining Classes; Code Points not listed
     * got Combining Class 0.
     *
     * @static
     * @var array
     * @access private
     */
    private static $_np_norm_combcls = array(
        0x334   =&gt; 1,
        0x335   =&gt; 1,
        0x336   =&gt; 1,
        0x337   =&gt; 1,
        0x338   =&gt; 1,
        0x93C   =&gt; 7,
        0x9BC   =&gt; 7,
        0xA3C   =&gt; 7,
        0xABC   =&gt; 7,
        0xB3C   =&gt; 7,
        0xCBC   =&gt; 7,
        0x1037  =&gt; 7,
        0x3099  =&gt; 8,
        0x309A  =&gt; 8,
        0x94D   =&gt; 9,
        0x9CD   =&gt; 9,
        0xA4D   =&gt; 9,
        0xACD   =&gt; 9,
        0xB4D   =&gt; 9,
        0xBCD   =&gt; 9,
        0xC4D   =&gt; 9,
        0xCCD   =&gt; 9,
        0xD4D   =&gt; 9,
        0xDCA   =&gt; 9,
        0xE3A   =&gt; 9,
        0xF84   =&gt; 9,
        0x1039  =&gt; 9,
        0x1714  =&gt; 9,
        0x1734  =&gt; 9,
        0x17D2  =&gt; 9,
        0x5B0   =&gt; 10,
        0x5B1   =&gt; 11,
        0x5B2   =&gt; 12,
        0x5B3   =&gt; 13,
        0x5B4   =&gt; 14,
        0x5B5   =&gt; 15,
        0x5B6   =&gt; 16,
        0x5B7   =&gt; 17,
        0x5B8   =&gt; 18,
        0x5B9   =&gt; 19,
        0x5BB   =&gt; 20,
        0x5Bc   =&gt; 21,
        0x5BD   =&gt; 22,
        0x5BF   =&gt; 23,
        0x5C1   =&gt; 24,
        0x5C2   =&gt; 25,
        0xFB1E  =&gt; 26,
        0x64B   =&gt; 27,
        0x64C   =&gt; 28,
        0x64D   =&gt; 29,
        0x64E   =&gt; 30,
        0x64F   =&gt; 31,
        0x650   =&gt; 32,
        0x651   =&gt; 33,
        0x652   =&gt; 34,
        0x670   =&gt; 35,
        0x711   =&gt; 36,
        0xC55   =&gt; 84,
        0xC56   =&gt; 91,
        0xE38   =&gt; 103,
        0xE39   =&gt; 103,
        0xE48   =&gt; 107,
        0xE49   =&gt; 107,
        0xE4A   =&gt; 107,
        0xE4B   =&gt; 107,
        0xEB8   =&gt; 118,
        0xEB9   =&gt; 118,
        0xEC8   =&gt; 122,
        0xEC9   =&gt; 122,
        0xECA   =&gt; 122,
        0xECB   =&gt; 122,
        0xF71   =&gt; 129,
        0xF72   =&gt; 130,
        0xF7A   =&gt; 130,
        0xF7B   =&gt; 130,
        0xF7C   =&gt; 130,
        0xF7D   =&gt; 130,
        0xF80   =&gt; 130,
        0xF74   =&gt; 132,
        0x321   =&gt; 202,
        0x322   =&gt; 202,
        0x327   =&gt; 202,
        0x328   =&gt; 202,
        0x31B   =&gt; 216,
        0xF39   =&gt; 216,
        0x1D165 =&gt; 216,
        0x1D166 =&gt; 216,
        0x1D16E =&gt; 216,
        0x1D16F =&gt; 216,
        0x1D170 =&gt; 216,
        0x1D171 =&gt; 216,
        0x1D172 =&gt; 216,
        0x302A  =&gt; 218,
        0x316   =&gt; 220,
        0x317   =&gt; 220,
        0x318   =&gt; 220,
        0x319   =&gt; 220,
        0x31C   =&gt; 220,
        0x31D   =&gt; 220,
        0x31E   =&gt; 220,
        0x31F   =&gt; 220,
        0x320   =&gt; 220,
        0x323   =&gt; 220,
        0x324   =&gt; 220,
        0x325   =&gt; 220,
        0x326   =&gt; 220,
        0x329   =&gt; 220,
        0x32A   =&gt; 220,
        0x32B   =&gt; 220,
        0x32C   =&gt; 220,
        0x32D   =&gt; 220,
        0x32E   =&gt; 220,
        0x32F   =&gt; 220,
        0x330   =&gt; 220,
        0x331   =&gt; 220,
        0x332   =&gt; 220,
        0x333   =&gt; 220,
        0x339   =&gt; 220,
        0x33A   =&gt; 220,
        0x33B   =&gt; 220,
        0x33C   =&gt; 220,
        0x347   =&gt; 220,
        0x348   =&gt; 220,
        0x349   =&gt; 220,
        0x34D   =&gt; 220,
        0x34E   =&gt; 220,
        0x353   =&gt; 220,
        0x354   =&gt; 220,
        0x355   =&gt; 220,
        0x356   =&gt; 220,
        0x591   =&gt; 220,
        0x596   =&gt; 220,
        0x59B   =&gt; 220,
        0x5A3   =&gt; 220,
        0x5A4   =&gt; 220,
        0x5A5   =&gt; 220,
        0x5A6   =&gt; 220,
        0x5A7   =&gt; 220,
        0x5AA   =&gt; 220,
        0x655   =&gt; 220,
        0x656   =&gt; 220,
        0x6E3   =&gt; 220,
        0x6EA   =&gt; 220,
        0x6ED   =&gt; 220,
        0x731   =&gt; 220,
        0x734   =&gt; 220,
        0x737   =&gt; 220,
        0x738   =&gt; 220,
        0x739   =&gt; 220,
        0x73B   =&gt; 220,
        0x73C   =&gt; 220,
        0x73E   =&gt; 220,
        0x742   =&gt; 220,
        0x744   =&gt; 220,
        0x746   =&gt; 220,
        0x748   =&gt; 220,
        0x952   =&gt; 220,
        0xF18   =&gt; 220,
        0xF19   =&gt; 220,
        0xF35   =&gt; 220,
        0xF37   =&gt; 220,
        0xFC6   =&gt; 220,
        0x193B  =&gt; 220,
        0x20E8  =&gt; 220,
        0x1D17B =&gt; 220,
        0x1D17C =&gt; 220,
        0x1D17D =&gt; 220,
        0x1D17E =&gt; 220,
        0x1D17F =&gt; 220,
        0x1D180 =&gt; 220,
        0x1D181 =&gt; 220,
        0x1D182 =&gt; 220,
        0x1D18A =&gt; 220,
        0x1D18B =&gt; 220,
        0x59A   =&gt; 222,
        0x5AD   =&gt; 222,
        0x1929  =&gt; 222,
        0x302D  =&gt; 222,
        0x302E  =&gt; 224,
        0x302F  =&gt; 224,
        0x1D16D =&gt; 226,
        0x5AE   =&gt; 228,
        0x18A9  =&gt; 228,
        0x302B  =&gt; 228,
        0x300   =&gt; 230,
        0x301   =&gt; 230,
        0x302   =&gt; 230,
        0x303   =&gt; 230,
        0x304   =&gt; 230,
        0x305   =&gt; 230,
        0x306   =&gt; 230,
        0x307   =&gt; 230,
        0x308   =&gt; 230,
        0x309   =&gt; 230,
        0x30A   =&gt; 230,
        0x30B   =&gt; 230,
        0x30C   =&gt; 230,
        0x30D   =&gt; 230,
        0x30E   =&gt; 230,
        0x30F   =&gt; 230,
        0x310   =&gt; 230,
        0x311   =&gt; 230,
        0x312   =&gt; 230,
        0x313   =&gt; 230,
        0x314   =&gt; 230,
        0x33D   =&gt; 230,
        0x33E   =&gt; 230,
        0x33F   =&gt; 230,
        0x340   =&gt; 230,
        0x341   =&gt; 230,
        0x342   =&gt; 230,
        0x343   =&gt; 230,
        0x344   =&gt; 230,
        0x346   =&gt; 230,
        0x34A   =&gt; 230,
        0x34B   =&gt; 230,
        0x34C   =&gt; 230,
        0x350   =&gt; 230,
        0x351   =&gt; 230,
        0x352   =&gt; 230,
        0x357   =&gt; 230,
        0x363   =&gt; 230,
        0x364   =&gt; 230,
        0x365   =&gt; 230,
        0x366   =&gt; 230,
        0x367   =&gt; 230,
        0x368   =&gt; 230,
        0x369   =&gt; 230,
        0x36A   =&gt; 230,
        0x36B   =&gt; 230,
        0x36C   =&gt; 230,
        0x36D   =&gt; 230,
        0x36E   =&gt; 230,
        0x36F   =&gt; 230,
        0x483   =&gt; 230,
        0x484   =&gt; 230,
        0x485   =&gt; 230,
        0x486   =&gt; 230,
        0x592   =&gt; 230,
        0x593   =&gt; 230,
        0x594   =&gt; 230,
        0x595   =&gt; 230,
        0x597   =&gt; 230,
        0x598   =&gt; 230,
        0x599   =&gt; 230,
        0x59C   =&gt; 230,
        0x59D   =&gt; 230,
        0x59E   =&gt; 230,
        0x59F   =&gt; 230,
        0x5A0   =&gt; 230,
        0x5A1   =&gt; 230,
        0x5A8   =&gt; 230,
        0x5A9   =&gt; 230,
        0x5AB   =&gt; 230,
        0x5AC   =&gt; 230,
        0x5AF   =&gt; 230,
        0x5C4   =&gt; 230,
        0x610   =&gt; 230,
        0x611   =&gt; 230,
        0x612   =&gt; 230,
        0x613   =&gt; 230,
        0x614   =&gt; 230,
        0x615   =&gt; 230,
        0x653   =&gt; 230,
        0x654   =&gt; 230,
        0x657   =&gt; 230,
        0x658   =&gt; 230,
        0x6D6   =&gt; 230,
        0x6D7   =&gt; 230,
        0x6D8   =&gt; 230,
        0x6D9   =&gt; 230,
        0x6DA   =&gt; 230,
        0x6DB   =&gt; 230,
        0x6DC   =&gt; 230,
        0x6DF   =&gt; 230,
        0x6E0   =&gt; 230,
        0x6E1   =&gt; 230,
        0x6E2   =&gt; 230,
        0x6E4   =&gt; 230,
        0x6E7   =&gt; 230,
        0x6E8   =&gt; 230,
        0x6EB   =&gt; 230,
        0x6EC   =&gt; 230,
        0x730   =&gt; 230,
        0x732   =&gt; 230,
        0x733   =&gt; 230,
        0x735   =&gt; 230,
        0x736   =&gt; 230,
        0x73A   =&gt; 230,
        0x73D   =&gt; 230,
        0x73F   =&gt; 230,
        0x740   =&gt; 230,
        0x741   =&gt; 230,
        0x743   =&gt; 230,
        0x745   =&gt; 230,
        0x747   =&gt; 230,
        0x749   =&gt; 230,
        0x74A   =&gt; 230,
        0x951   =&gt; 230,
        0x953   =&gt; 230,
        0x954   =&gt; 230,
        0xF82   =&gt; 230,
        0xF83   =&gt; 230,
        0xF86   =&gt; 230,
        0xF87   =&gt; 230,
        0x170D  =&gt; 230,
        0x193A  =&gt; 230,
        0x20D0  =&gt; 230,
        0x20D1  =&gt; 230,
        0x20D4  =&gt; 230,
        0x20D5  =&gt; 230,
        0x20D6  =&gt; 230,
        0x20D7  =&gt; 230,
        0x20DB  =&gt; 230,
        0x20DC  =&gt; 230,
        0x20E1  =&gt; 230,
        0x20E7  =&gt; 230,
        0x20E9  =&gt; 230,
        0xFE20  =&gt; 230,
        0xFE21  =&gt; 230,
        0xFE22  =&gt; 230,
        0xFE23  =&gt; 230,
        0x1D185 =&gt; 230,
        0x1D186 =&gt; 230,
        0x1D187 =&gt; 230,
        0x1D189 =&gt; 230,
        0x1D188 =&gt; 230,
        0x1D1AA =&gt; 230,
        0x1D1AB =&gt; 230,
        0x1D1AC =&gt; 230,
        0x1D1AD =&gt; 230,
        0x315   =&gt; 232,
        0x31A   =&gt; 232,
        0x302C  =&gt; 232,
        0x35F   =&gt; 233,
        0x362   =&gt; 233,
        0x35D   =&gt; 234,
        0x35E   =&gt; 234,
        0x360   =&gt; 234,
        0x361   =&gt; 234,
        0x345   =&gt; 240
    );
    // }}}

    // {{{ properties
    /**
     * @var string
     * @access private
     */
    private $_punycode_prefix = &#039;xn--&#039;;

    /**
     * @access private
     */
    private $_invalid_ucs = 0x80000000;

    /**
     * @access private
     */
    private $_max_ucs = 0x10FFFF;

    /**
     * @var int
     * @access private
     */
    private $_base = 36;

    /**
     * @var int
     * @access private
     */
    private $_tmin = 1;

    /**
     * @var int
     * @access private
     */
    private $_tmax = 26;

    /**
     * @var int
     * @access private
     */
    private $_skew = 38;

    /**
     * @var int
     * @access private
     */
    private $_damp = 700;

    /**
     * @var int
     * @access private
     */
    private $_initial_bias = 72;

    /**
     * @var int
     * @access private
     */
    private $_initial_n = 0x80;

    /**
     * @var int
     * @access private
     */
    private $_slast;

    /**
     * @access private
     */
    private $_sbase = 0xAC00;

    /**
     * @access private
     */
    private $_lbase = 0x1100;

    /**
     * @access private
     */
    private $_vbase = 0x1161;

    /**
     * @access private
     */
    private $_tbase = 0x11a7;

    /**
     * @var int
     * @access private
     */
    private $_lcount = 19;

    /**
     * @var int
     * @access private
     */
    private $_vcount = 21;

    /**
     * @var int
     * @access private
     */
    private $_tcount = 28;

    /**
     * vcount * tcount
     *
     * @var int
     * @access private
     */
    private $_ncount = 588;

    /**
     * lcount * tcount * vcount
     *
     * @var int
     * @access private
     */
    private $_scount = 11172;

    /**
     * Default encoding for encode()&#039;s input and decode()&#039;s output is UTF-8;
     * Other possible encodings are ucs4_string and ucs4_array
     * See {@link setParams()} for how to select these
     *
     * @var bool
     * @access private
     */
    private $_api_encoding = &#039;utf8&#039;;

    /**
     * Overlong UTF-8 encodings are forbidden
     *
     * @var bool
     * @access private
     */
    private $_allow_overlong = false;

    /**
     * Behave strict or not
     *
     * @var bool
     * @access private
     */
    private $_strict_mode = false;

    /**
     * IDNA-version to use
     *
     * Values are &quot;2003&quot; and &quot;2008&quot;.
     * Defaults to &quot;2003&quot;, since that was the original version and for
     * compatibility with previous versions of this library.
     * If you need to encode &quot;new&quot; characters like the German &quot;Eszett&quot;,
     * please switch to 2008 first before encoding.
     *
     * @var bool
     * @access private
     */
    private $_version = &#039;2003&#039;;

    /**
     * Cached value indicating whether or not mbstring function overloading is
     * on for strlen
     *
     * This is cached for optimal performance.
     *
     * @var boolean
     * @see Net_IDNA2::_byteLength()
     */
    private static $_mb_string_overload = null;
    // }}}


    // {{{ constructor
    /**
     * Constructor
     *
     * @param array $options Options to initialise the object with
     *
     * @access public
     * @see    setParams()
     */
    public function __construct($options = null)
    {
        $this-&gt;_slast = $this-&gt;_sbase + $this-&gt;_lcount * $this-&gt;_vcount * $this-&gt;_tcount;

        if (is_array($options)) {
            $this-&gt;setParams($options);
        }

        // populate mbstring overloading cache if not set
        if (self::$_mb_string_overload === null) {
            self::$_mb_string_overload = (extension_loaded(&#039;mbstring&#039;)
                &amp;&amp; (ini_get(&#039;mbstring.func_overload&#039;) &amp; 0x02) === 0x02);
        }
    }
    // }}}


    /**
     * Sets a new option value. Available options and values:
     *
     * [utf8 -     Use either UTF-8 or ISO-8859-1 as input (true for UTF-8, false
     *             otherwise); The output is always UTF-8]
     * [overlong - Unicode does not allow unnecessarily long encodings of chars,
     *             to allow this, set this parameter to true, else to false;
     *             default is false.]
     * [strict -   true: strict mode, good for registration purposes - Causes errors
     *             on failures; false: loose mode, ideal for &quot;wildlife&quot; applications
     *             by silently ignoring errors and returning the original input instead]
     *
     * @param mixed  $option Parameter to set (string: single parameter; array of Parameter =&gt; Value pairs)
     * @param string $value  Value to use (if parameter 1 is a string)
     *
     * @return boolean       true on success, false otherwise
     * @access public
     */
    public function setParams($option, $value = false)
    {
        if (!is_array($option)) {
            $option = array($option =&gt; $value);
        }

        foreach ($option as $k =&gt; $v) {
            switch ($k) {
            case &#039;encoding&#039;:
                switch ($v) {
                case &#039;utf8&#039;:
                case &#039;ucs4_string&#039;:
                case &#039;ucs4_array&#039;:
                    $this-&gt;_api_encoding = $v;
                    break;

                default:
                    throw new InvalidArgumentException(&#039;Set Parameter: Unknown parameter &#039;.$v.&#039; for option &#039;.$k);
                }

                break;

            case &#039;overlong&#039;:
                $this-&gt;_allow_overlong = ($v) ? true : false;
                break;

            case &#039;strict&#039;:
                $this-&gt;_strict_mode = ($v) ? true : false;
                break;

            case &#039;version&#039;:
                if (in_array($v, array(&#039;2003&#039;, &#039;2008&#039;))) {
                    $this-&gt;_version = $v;
                } else {
                    throw new InvalidArgumentException(&#039;Set Parameter: Invalid parameter &#039;.$v.&#039; for option &#039;.$k);
                }
                break;

            default:
                return false;
            }
        }

        return true;
    }

    /**
     * Encode a given UTF-8 domain name.
     *
     * @param string $decoded           Domain name (UTF-8 or UCS-4)
     * @param string $one_time_encoding Desired input encoding, see {@link set_parameter}
     *                                  If not given will use default-encoding
     *
     * @return string Encoded Domain name (ACE string)
     * @return mixed  processed string
     * @throws Exception
     * @access public
     */
    public function encode($decoded, $one_time_encoding = false)
    {
        // Forcing conversion of input to UCS4 array
        // If one time encoding is given, use this, else the objects property
        switch (($one_time_encoding) ? $one_time_encoding : $this-&gt;_api_encoding) {
        case &#039;utf8&#039;:
            $decoded = $this-&gt;_utf8_to_ucs4($decoded);
            break;
        case &#039;ucs4_string&#039;:
            $decoded = $this-&gt;_ucs4_string_to_ucs4($decoded);
        case &#039;ucs4_array&#039;: // No break; before this line. Catch case, but do nothing
            break;
        default:
            throw new InvalidArgumentException(&#039;Unsupported input format&#039;);
        }

        // No input, no output, what else did you expect?
        if (empty($decoded)) return &#039;&#039;;

        // Anchors for iteration
        $last_begin = 0;
        // Output string
        $output = &#039;&#039;;

        foreach ($decoded as $k =&gt; $v) {
            // Make sure to use just the plain dot
            switch($v) {
            case 0x3002:
            case 0xFF0E:
            case 0xFF61:
                $decoded[$k] = 0x2E;
                // It&#039;s right, no break here
                // The codepoints above have to be converted to dots anyway

            // Stumbling across an anchoring character
            case 0x2E:
            case 0x2F:
            case 0x3A:
            case 0x3F:
            case 0x40:
                // Neither email addresses nor URLs allowed in strict mode
                if ($this-&gt;_strict_mode) {
                    throw new InvalidArgumentException(&#039;Neither email addresses nor URLs are allowed in strict mode.&#039;);
                }
                // Skip first char
                if ($k) {
                    $encoded = &#039;&#039;;
                    $encoded = $this-&gt;_encode(array_slice($decoded, $last_begin, (($k)-$last_begin)));
                    if ($encoded) {
                        $output .= $encoded;
                    } else {
                        $output .= $this-&gt;_ucs4_to_utf8(array_slice($decoded, $last_begin, (($k)-$last_begin)));
                    }
                    $output .= chr($decoded[$k]);
                }
                $last_begin = $k + 1;
            }
        }
        // Catch the rest of the string
        if ($last_begin) {
            $inp_len = sizeof($decoded);
            $encoded = &#039;&#039;;
            $encoded = $this-&gt;_encode(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
            if ($encoded) {
                $output .= $encoded;
            } else {
                $output .= $this-&gt;_ucs4_to_utf8(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
            }
            return $output;
        }

        if ($output = $this-&gt;_encode($decoded)) {
            return $output;
        }

        return $this-&gt;_ucs4_to_utf8($decoded);
    }

    /**
     * Decode a given ACE domain name.
     *
     * @param string $input             Domain name (ACE string)
     * @param string $one_time_encoding Desired output encoding, see {@link set_parameter}
     *
     * @return string                   Decoded Domain name (UTF-8 or UCS-4)
     * @throws Exception
     * @access public
     */
    public function decode($input, $one_time_encoding = false)
    {
        // Optionally set
        if ($one_time_encoding) {
            switch ($one_time_encoding) {
            case &#039;utf8&#039;:
            case &#039;ucs4_string&#039;:
            case &#039;ucs4_array&#039;:
                break;
            default:
                throw new InvalidArgumentException(&#039;Unknown encoding &#039;.$one_time_encoding);
            }
        }
        // Make sure to drop any newline characters around
        $input = trim($input);

        // Negotiate input and try to determine, whether it is a plain string,
        // an email address or something like a complete URL
        if (strpos($input, &#039;@&#039;)) { // Maybe it is an email address
            // No no in strict mode
            if ($this-&gt;_strict_mode) {
                throw new InvalidArgumentException(&#039;Only simple domain name parts can be handled in strict mode&#039;);
            }
            list($email_pref, $input) = explode(&#039;@&#039;, $input, 2);
            $arr = explode(&#039;.&#039;, $input);
            foreach ($arr as $k =&gt; $v) {
                $conv = $this-&gt;_decode($v);
                if ($conv) $arr[$k] = $conv;
            }
            $return = $email_pref . &#039;@&#039; . join(&#039;.&#039;, $arr);
        } elseif (preg_match(&#039;![:\./]!&#039;, $input)) { // Or a complete domain name (with or without paths / parameters)
            // No no in strict mode
            if ($this-&gt;_strict_mode) {
                throw new InvalidArgumentException(&#039;Only simple domain name parts can be handled in strict mode&#039;);
            }

            $parsed = parse_url($input);
            if (isset($parsed[&#039;host&#039;])) {
                $arr = explode(&#039;.&#039;, $parsed[&#039;host&#039;]);
                foreach ($arr as $k =&gt; $v) {
                    $conv = $this-&gt;_decode($v);
                    if ($conv) $arr[$k] = $conv;
                }
                $parsed[&#039;host&#039;] = join(&#039;.&#039;, $arr);
                if (isset($parsed[&#039;scheme&#039;])) {
                    $parsed[&#039;scheme&#039;] .= (strtolower($parsed[&#039;scheme&#039;]) == &#039;mailto&#039;) ? &#039;:&#039; : &#039;://&#039;;
                }
                $return = $this-&gt;_unparse_url($parsed);
            } else { // parse_url seems to have failed, try without it
                $arr = explode(&#039;.&#039;, $input);
                foreach ($arr as $k =&gt; $v) {
                    $conv = $this-&gt;_decode($v);
                    if ($conv) $arr[$k] = $conv;
                }
                $return = join(&#039;.&#039;, $arr);
            }
        } else { // Otherwise we consider it being a pure domain name string
            $return = $this-&gt;_decode($input);
        }
        // The output is UTF-8 by default, other output formats need conversion here
        // If one time encoding is given, use this, else the objects property
        switch (($one_time_encoding) ? $one_time_encoding : $this-&gt;_api_encoding) {
        case &#039;utf8&#039;:
            return $return;
            break;
        case &#039;ucs4_string&#039;:
            return $this-&gt;_ucs4_to_ucs4_string($this-&gt;_utf8_to_ucs4($return));
            break;
        case &#039;ucs4_array&#039;:
            return $this-&gt;_utf8_to_ucs4($return);
            break;
        default:
            throw new InvalidArgumentException(&#039;Unsupported output format&#039;);
        }
    }


    // {{{ private
    /**
     * Opposite function to parse_url()
     *
     * Inspired by code from comments of php.net-documentation for parse_url()
     *
     * @param array $parts_arr parts (strings) as returned by parse_url()
     *
     * @return string
     * @access private
     */
    private function _unparse_url($parts_arr)
    {
        if (!empty($parts_arr[&#039;scheme&#039;])) {
            $ret_url = $parts_arr[&#039;scheme&#039;];
        }
        if (!empty($parts_arr[&#039;user&#039;])) {
            $ret_url .= $parts_arr[&#039;user&#039;];
            if (!empty($parts_arr[&#039;pass&#039;])) {
                $ret_url .= &#039;:&#039; . $parts_arr[&#039;pass&#039;];
            }
            $ret_url .= &#039;@&#039;;
        }
        $ret_url .= $parts_arr[&#039;host&#039;];
        if (!empty($parts_arr[&#039;port&#039;])) {
            $ret_url .= &#039;:&#039; . $parts_arr[&#039;port&#039;];
        }
        $ret_url .= $parts_arr[&#039;path&#039;];
        if (!empty($parts_arr[&#039;query&#039;])) {
            $ret_url .= &#039;?&#039; . $parts_arr[&#039;query&#039;];
        }
        if (!empty($parts_arr[&#039;fragment&#039;])) {
            $ret_url .= &#039;#&#039; . $parts_arr[&#039;fragment&#039;];
        }
        return $ret_url;
    }

    /**
     * The actual encoding algorithm.
     *
     * @param string $decoded Decoded string which should be encoded
     *
     * @return string         Encoded string
     * @throws Exception
     * @access private
     */
    private function _encode($decoded)
    {
        // We cannot encode a domain name containing the Punycode prefix
        $extract = self::_byteLength($this-&gt;_punycode_prefix);
        $check_pref = $this-&gt;_utf8_to_ucs4($this-&gt;_punycode_prefix);
        $check_deco = array_slice($decoded, 0, $extract);

        if ($check_pref == $check_deco) {
            throw new InvalidArgumentException(&#039;This is already a punycode string&#039;);
        }

        // We will not try to encode strings consisting of basic code points only
        $encodable = false;
        foreach ($decoded as $k =&gt; $v) {
            if ($v &gt; 0x7a) {
                $encodable = true;
                break;
            }
        }
        if (!$encodable) {
            if ($this-&gt;_strict_mode) {
                throw new InvalidArgumentException(&#039;The given string does not contain encodable chars&#039;);
            }

            return false;
        }

        // Do NAMEPREP
        $decoded = $this-&gt;_nameprep($decoded);

        $deco_len = count($decoded);

        // Empty array
        if (!$deco_len) {
            return false;
        }

        // How many chars have been consumed
        $codecount = 0;

        // Start with the prefix; copy it to output
        $encoded = $this-&gt;_punycode_prefix;

        $encoded = &#039;&#039;;
        // Copy all basic code points to output
        for ($i = 0; $i &lt; $deco_len; ++$i) {
            $test = $decoded[$i];
            // Will match [0-9a-zA-Z-]
            if ((0x2F &lt; $test &amp;&amp; $test &lt; 0x40)
                || (0x40 &lt; $test &amp;&amp; $test &lt; 0x5B)
                || (0x60 &lt; $test &amp;&amp; $test &lt;= 0x7B)
                || (0x2D == $test)
            ) {
                $encoded .= chr($decoded[$i]);
                $codecount++;
            }
        }

        // All codepoints were basic ones
        if ($codecount == $deco_len) {
            return $encoded;
        }

        // Start with the prefix; copy it to output
        $encoded = $this-&gt;_punycode_prefix . $encoded;

        // If we have basic code points in output, add an hyphen to the end
        if ($codecount) {
            $encoded .= &#039;-&#039;;
        }

        // Now find and encode all non-basic code points
        $is_first  = true;
        $cur_code  = $this-&gt;_initial_n;
        $bias      = $this-&gt;_initial_bias;
        $delta     = 0;

        while ($codecount &lt; $deco_len) {
            // Find the smallest code point &gt;= the current code point and
            // remember the last ouccrence of it in the input
            for ($i = 0, $next_code = $this-&gt;_max_ucs; $i &lt; $deco_len; $i++) {
                if ($decoded[$i] &gt;= $cur_code &amp;&amp; $decoded[$i] &lt;= $next_code) {
                    $next_code = $decoded[$i];
                }
            }

            $delta += ($next_code - $cur_code) * ($codecount + 1);
            $cur_code = $next_code;

            // Scan input again and encode all characters whose code point is $cur_code
            for ($i = 0; $i &lt; $deco_len; $i++) {
                if ($decoded[$i] &lt; $cur_code) {
                    $delta++;
                } else if ($decoded[$i] == $cur_code) {
                    for ($q = $delta, $k = $this-&gt;_base; 1; $k += $this-&gt;_base) {
                        $t = ($k &lt;= $bias)?
                            $this-&gt;_tmin :
                            (($k &gt;= $bias + $this-&gt;_tmax)? $this-&gt;_tmax : $k - $bias);

                        if ($q &lt; $t) {
                            break;
                        }

                        $encoded .= $this-&gt;_encodeDigit(ceil($t + (($q - $t) % ($this-&gt;_base - $t))));
                        $q = ($q - $t) / ($this-&gt;_base - $t);
                    }

                    $encoded .= $this-&gt;_encodeDigit($q);
                    $bias = $this-&gt;_adapt($delta, $codecount + 1, $is_first);
                    $codecount++;
                    $delta = 0;
                    $is_first = false;
                }
            }

            $delta++;
            $cur_code++;
        }

        return $encoded;
    }

    /**
     * The actual decoding algorithm.
     *
     * @param string $encoded Encoded string which should be decoded
     *
     * @return string         Decoded string
     * @throws Exception
     * @access private
     */
    private function _decode($encoded)
    {
        // We do need to find the Punycode prefix
        if (!preg_match(&#039;!^&#039; . preg_quote($this-&gt;_punycode_prefix, &#039;!&#039;) . &#039;!&#039;, $encoded)) {
            return false;
        }

        $encode_test = preg_replace(&#039;!^&#039; . preg_quote($this-&gt;_punycode_prefix, &#039;!&#039;) . &#039;!&#039;, &#039;&#039;, $encoded);

        // If nothing left after removing the prefix, it is hopeless
        if (!$encode_test) {
            return false;
        }

        // Find last occurrence of the delimiter
        $delim_pos = strrpos($encoded, &#039;-&#039;);

        if ($delim_pos &gt; self::_byteLength($this-&gt;_punycode_prefix)) {
            for ($k = self::_byteLength($this-&gt;_punycode_prefix); $k &lt; $delim_pos; ++$k) {
                $decoded[] = ord($encoded{$k});
            }
        } else {
            $decoded = array();
        }

        $deco_len = count($decoded);
        $enco_len = self::_byteLength($encoded);

        // Wandering through the strings; init
        $is_first = true;
        $bias     = $this-&gt;_initial_bias;
        $idx      = 0;
        $char     = $this-&gt;_initial_n;

        for ($enco_idx = ($delim_pos)? ($delim_pos + 1) : 0; $enco_idx &lt; $enco_len; ++$deco_len) {
            for ($old_idx = $idx, $w = 1, $k = $this-&gt;_base; 1 ; $k += $this-&gt;_base) {
                $digit = $this-&gt;_decodeDigit($encoded{$enco_idx++});
                $idx += $digit * $w;

                $t = ($k &lt;= $bias) ?
                    $this-&gt;_tmin :
                    (($k &gt;= $bias + $this-&gt;_tmax)? $this-&gt;_tmax : ($k - $bias));

                if ($digit &lt; $t) {
                    break;
                }

                $w = (int)($w * ($this-&gt;_base - $t));
            }

            $bias      = $this-&gt;_adapt($idx - $old_idx, $deco_len + 1, $is_first);
            $is_first  = false;
            $char     += (int) ($idx / ($deco_len + 1));
            $idx      %= ($deco_len + 1);

            if ($deco_len &gt; 0) {
                // Make room for the decoded char
                for ($i = $deco_len; $i &gt; $idx; $i--) {
                    $decoded[$i] = $decoded[($i - 1)];
                }
            }

            $decoded[$idx++] = $char;
        }

        return $this-&gt;_ucs4_to_utf8($decoded);
    }

    /**
     * Adapt the bias according to the current code point and position.
     *
     * @param int     $delta    ...
     * @param int     $npoints  ...
     * @param boolean $is_first ...
     *
     * @return int
     * @access private
     */
    private function _adapt($delta, $npoints, $is_first)
    {
        $delta = (int) ($is_first ? ($delta / $this-&gt;_damp) : ($delta / 2));
        $delta += (int) ($delta / $npoints);

        for ($k = 0; $delta &gt; (($this-&gt;_base - $this-&gt;_tmin) * $this-&gt;_tmax) / 2; $k += $this-&gt;_base) {
            $delta = (int) ($delta / ($this-&gt;_base - $this-&gt;_tmin));
        }

        return (int) ($k + ($this-&gt;_base - $this-&gt;_tmin + 1) * $delta / ($delta + $this-&gt;_skew));
    }

    /**
     * Encoding a certain digit.
     *
     * @param int $d One digit to encode
     *
     * @return char  Encoded digit
     * @access private
     */
    private function _encodeDigit($d)
    {
        return chr($d + 22 + 75 * ($d &lt; 26));
    }

    /**
     * Decode a certain digit.
     *
     * @param char $cp One digit (character) to decode
     *
     * @return int     Decoded digit
     * @access private
     */
    private function _decodeDigit($cp)
    {
        $cp = ord($cp);
        return ($cp - 48 &lt; 10)? $cp - 22 : (($cp - 65 &lt; 26)? $cp - 65 : (($cp - 97 &lt; 26)? $cp - 97 : $this-&gt;_base));
    }

    /**
     * Do Nameprep according to RFC3491 and RFC3454.
     *
     * @param array $input Unicode Characters
     *
     * @return string      Unicode Characters, Nameprep&#039;d
     * @throws Exception
     * @access private
     */
    private function _nameprep($input)
    {
        $output = array();

        // Walking through the input array, performing the required steps on each of
        // the input chars and putting the result into the output array
        // While mapping required chars we apply the canonical ordering

        foreach ($input as $v) {
            // Map to nothing == skip that code point
            if (in_array($v, self::$_np_map_nothing)) {
                continue;
            }

            // Try to find prohibited input
            if (in_array($v, self::$_np_prohibit) || in_array($v, self::$_general_prohibited)) {
                throw new Net_IDNA2_Exception_Nameprep(&#039;Prohibited input U+&#039; . sprintf(&#039;%08X&#039;, $v));
            }

            foreach (self::$_np_prohibit_ranges as $range) {
                if ($range[0] &lt;= $v &amp;&amp; $v &lt;= $range[1]) {
                    throw new Net_IDNA2_Exception_Nameprep(&#039;Prohibited input U+&#039; . sprintf(&#039;%08X&#039;, $v));
                }
            }

            // Hangul syllable decomposition
            if (0xAC00 &lt;= $v &amp;&amp; $v &lt;= 0xD7AF) {
                foreach ($this-&gt;_hangulDecompose($v) as $out) {
                    $output[] = $out;
                }
            } else if (($this-&gt;_version == &#039;2003&#039;) &amp;&amp; isset(self::$_np_replacemaps[$v])) {
                // There&#039;s a decomposition mapping for that code point
                // Decompositions only in version 2003 (original) of IDNA
                foreach ($this-&gt;_applyCannonicalOrdering(self::$_np_replacemaps[$v]) as $out) {
                    $output[] = $out;
                }
            } else {
                $output[] = $v;
            }
        }

        // Combine code points

        $last_class   = 0;
        $last_starter = 0;
        $out_len      = count($output);

        for ($i = 0; $i &lt; $out_len; ++$i) {
            $class = $this-&gt;_getCombiningClass($output[$i]);

            if ((!$last_class || $last_class != $class) &amp;&amp; $class) {
                // Try to match
                $seq_len = $i - $last_starter;
                $out = $this-&gt;_combine(array_slice($output, $last_starter, $seq_len));

                // On match: Replace the last starter with the composed character and remove
                // the now redundant non-starter(s)
                if ($out) {
                    $output[$last_starter] = $out;

                    if (count($out) != $seq_len) {
                        for ($j = $i + 1; $j &lt; $out_len; ++$j) {
                            $output[$j - 1] = $output[$j];
                        }

                        unset($output[$out_len]);
                    }

                    // Rewind the for loop by one, since there can be more possible compositions
                    $i--;
                    $out_len--;
                    $last_class = ($i == $last_starter)? 0 : $this-&gt;_getCombiningClass($output[$i - 1]);

                    continue;
                }
            }

            // The current class is 0
            if (!$class) {
                $last_starter = $i;
            }

            $last_class = $class;
        }

        return $output;
    }

    /**
     * Decomposes a Hangul syllable
     * (see http://www.unicode.org/unicode/reports/tr15/#Hangul).
     *
     * @param integer $char 32bit UCS4 code point
     *
     * @return array        Either Hangul Syllable decomposed or original 32bit
     *                      value as one value array
     * @access private
     */
    private function _hangulDecompose($char)
    {
        $sindex = $char - $this-&gt;_sbase;

        if ($sindex &lt; 0 || $sindex &gt;= $this-&gt;_scount) {
            return array($char);
        }

        $result   = array();
        $T        = $this-&gt;_tbase + $sindex % $this-&gt;_tcount;
        $result[] = (int)($this-&gt;_lbase +  $sindex / $this-&gt;_ncount);
        $result[] = (int)($this-&gt;_vbase + ($sindex % $this-&gt;_ncount) / $this-&gt;_tcount);

        if ($T != $this-&gt;_tbase) {
            $result[] = $T;
        }

        return $result;
    }

    /**
     * Ccomposes a Hangul syllable
     * (see http://www.unicode.org/unicode/reports/tr15/#Hangul).
     *
     * @param array $input Decomposed UCS4 sequence
     *
     * @return array       UCS4 sequence with syllables composed
     * @access private
     */
    private function _hangulCompose($input)
    {
        $inp_len = count($input);

        if (!$inp_len) {
            return array();
        }

        $result   = array();
        $last     = $input[0];
        $result[] = $last; // copy first char from input to output

        for ($i = 1; $i &lt; $inp_len; ++$i) {
            $char = $input[$i];

            // Find out, wether two current characters from L and V
            $lindex = $last - $this-&gt;_lbase;

            if (0 &lt;= $lindex &amp;&amp; $lindex &lt; $this-&gt;_lcount) {
                $vindex = $char - $this-&gt;_vbase;

                if (0 &lt;= $vindex &amp;&amp; $vindex &lt; $this-&gt;_vcount) {
                    // create syllable of form LV
                    $last    = ($this-&gt;_sbase + ($lindex * $this-&gt;_vcount + $vindex) * $this-&gt;_tcount);
                    $out_off = count($result) - 1;
                    $result[$out_off] = $last; // reset last

                    // discard char
                    continue;
                }
            }

            // Find out, wether two current characters are LV and T
            $sindex = $last - $this-&gt;_sbase;

            if (0 &lt;= $sindex &amp;&amp; $sindex &lt; $this-&gt;_scount &amp;&amp; ($sindex % $this-&gt;_tcount) == 0) {
                $tindex = $char - $this-&gt;_tbase;

                if (0 &lt;= $tindex &amp;&amp; $tindex &lt;= $this-&gt;_tcount) {
                    // create syllable of form LVT
                    $last += $tindex;
                    $out_off = count($result) - 1;
                    $result[$out_off] = $last; // reset last

                    // discard char
                    continue;
                }
            }

            // if neither case was true, just add the character
            $last = $char;
            $result[] = $char;
        }

        return $result;
    }

    /**
     * Returns the combining class of a certain wide char.
     *
     * @param integer $char Wide char to check (32bit integer)
     *
     * @return integer      Combining class if found, else 0
     * @access private
     */
    private function _getCombiningClass($char)
    {
        return isset(self::$_np_norm_combcls[$char])? self::$_np_norm_combcls[$char] : 0;
    }

    /**
     * Apllies the canonical ordering of a decomposed UCS4 sequence.
     *
     * @param array $input Decomposed UCS4 sequence
     *
     * @return array       Ordered USC4 sequence
     * @access private
     */
    private function _applyCannonicalOrdering($input)
    {
        $swap = true;
        $size = count($input);

        while ($swap) {
            $swap = false;
            $last = $this-&gt;_getCombiningClass($input[0]);

            for ($i = 0; $i &lt; $size - 1; ++$i) {
                $next = $this-&gt;_getCombiningClass($input[$i + 1]);

                if ($next != 0 &amp;&amp; $last &gt; $next) {
                    // Move item leftward until it fits
                    for ($j = $i + 1; $j &gt; 0; --$j) {
                        if ($this-&gt;_getCombiningClass($input[$j - 1]) &lt;= $next) {
                            break;
                        }

                        $t = $input[$j];
                        $input[$j] = $input[$j - 1];
                        $input[$j - 1] = $t;
                        $swap = 1;
                    }

                    // Reentering the loop looking at the old character again
                    $next = $last;
                }

                $last = $next;
            }
        }

        return $input;
    }

    /**
     * Do composition of a sequence of starter and non-starter.
     *
     * @param array $input UCS4 Decomposed sequence
     *
     * @return array       Ordered USC4 sequence
     * @access private
     */
    private function _combine($input)
    {
        $inp_len = count($input);

        // Is it a Hangul syllable?
        if (1 != $inp_len) {
            $hangul = $this-&gt;_hangulCompose($input);

            // This place is probably wrong
            if (count($hangul) != $inp_len) {
                return $hangul;
            }
        }

        foreach (self::$_np_replacemaps as $np_src =&gt; $np_target) {
            if ($np_target[0] != $input[0]) {
                continue;
            }

            if (count($np_target) != $inp_len) {
                continue;
            }

            $hit = false;

            foreach ($input as $k2 =&gt; $v2) {
                if ($v2 == $np_target[$k2]) {
                    $hit = true;
                } else {
                    $hit = false;
                    break;
                }
            }

            if ($hit) {
                return $np_src;
            }
        }

        return false;
    }

    /**
     * This converts an UTF-8 encoded string to its UCS-4 (array) representation
     * By talking about UCS-4 we mean arrays of 32bit integers representing
     * each of the &quot;chars&quot;. This is due to PHP not being able to handle strings with
     * bit depth different from 8. This applies to the reverse method _ucs4_to_utf8(), too.
     * The following UTF-8 encodings are supported:
     *
     * bytes bits  representation
     * 1        7  0xxxxxxx
     * 2       11  110xxxxx 10xxxxxx
     * 3       16  1110xxxx 10xxxxxx 10xxxxxx
     * 4       21  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
     * 5       26  111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
     * 6       31  1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
     *
     * Each x represents a bit that can be used to store character data.
     *
     * @param string $input utf8-encoded string
     *
     * @return array        ucs4-encoded array
     * @throws Exception
     * @access private
     */
    private function _utf8_to_ucs4($input)
    {
        $output = array();
        $out_len = 0;
        $inp_len = self::_byteLength($input, &#039;8bit&#039;);
        $mode = &#039;next&#039;;
        $test = &#039;none&#039;;
        for ($k = 0; $k &lt; $inp_len; ++$k) {
            $v = ord($input{$k}); // Extract byte from input string

            if ($v &lt; 128) { // We found an ASCII char - put into string as is
                $output[$out_len] = $v;
                ++$out_len;
                if (&#039;add&#039; == $mode) {
                    throw new UnexpectedValueException(&#039;Conversion from UTF-8 to UCS-4 failed: malformed input at byte &#039;.$k);
                }
                continue;
            }
            if (&#039;next&#039; == $mode) { // Try to find the next start byte; determine the width of the Unicode char
                $start_byte = $v;
                $mode = &#039;add&#039;;
                $test = &#039;range&#039;;
                if ($v &gt;&gt; 5 == 6) { // &amp;110xxxxx 10xxxxx
                    $next_byte = 0; // Tells, how many times subsequent bitmasks must rotate 6bits to the left
                    $v = ($v - 192) &lt;&lt; 6;
                } elseif ($v &gt;&gt; 4 == 14) { // &amp;1110xxxx 10xxxxxx 10xxxxxx
                    $next_byte = 1;
                    $v = ($v - 224) &lt;&lt; 12;
                } elseif ($v &gt;&gt; 3 == 30) { // &amp;11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
                    $next_byte = 2;
                    $v = ($v - 240) &lt;&lt; 18;
                } elseif ($v &gt;&gt; 2 == 62) { // &amp;111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
                    $next_byte = 3;
                    $v = ($v - 248) &lt;&lt; 24;
                } elseif ($v &gt;&gt; 1 == 126) { // &amp;1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
                    $next_byte = 4;
                    $v = ($v - 252) &lt;&lt; 30;
                } else {
                    throw new UnexpectedValueException(&#039;This might be UTF-8, but I don\&#039;t understand it at byte &#039;.$k);
                }
                if (&#039;add&#039; == $mode) {
                    $output[$out_len] = (int) $v;
                    ++$out_len;
                    continue;
                }
            }
            if (&#039;add&#039; == $mode) {
                if (!$this-&gt;_allow_overlong &amp;&amp; $test == &#039;range&#039;) {
                    $test = &#039;none&#039;;
                    if (($v &lt; 0xA0 &amp;&amp; $start_byte == 0xE0) || ($v &lt; 0x90 &amp;&amp; $start_byte == 0xF0) || ($v &gt; 0x8F &amp;&amp; $start_byte == 0xF4)) {
                        throw new OutOfRangeException(&#039;Bogus UTF-8 character detected (out of legal range) at byte &#039;.$k);
                    }
                }
                if ($v &gt;&gt; 6 == 2) { // Bit mask must be 10xxxxxx
                    $v = ($v - 128) &lt;&lt; ($next_byte * 6);
                    $output[($out_len - 1)] += $v;
                    --$next_byte;
                } else {
                    throw new UnexpectedValueException(&#039;Conversion from UTF-8 to UCS-4 failed: malformed input at byte &#039;.$k);
                }
                if ($next_byte &lt; 0) {
                    $mode = &#039;next&#039;;
                }
            }
        } // for
        return $output;
    }

    /**
     * Convert UCS-4 array into UTF-8 string
     *
     * @param array $input ucs4-encoded array
     *
     * @return string      utf8-encoded string
     * @throws Exception
     * @access private
     */
    private function _ucs4_to_utf8($input)
    {
        $output = &#039;&#039;;

        foreach ($input as $v) {
            // $v = ord($v);

            if ($v &lt; 128) {
                // 7bit are transferred literally
                $output .= chr($v);
            } else if ($v &lt; 1 &lt;&lt; 11) {
                // 2 bytes
                $output .= chr(192 + ($v &gt;&gt; 6))
                    . chr(128 + ($v &amp; 63));
            } else if ($v &lt; 1 &lt;&lt; 16) {
                // 3 bytes
                $output .= chr(224 + ($v &gt;&gt; 12))
                    . chr(128 + (($v &gt;&gt; 6) &amp; 63))
                    . chr(128 + ($v &amp; 63));
            } else if ($v &lt; 1 &lt;&lt; 21) {
                // 4 bytes
                $output .= chr(240 + ($v &gt;&gt; 18))
                    . chr(128 + (($v &gt;&gt; 12) &amp; 63))
                    . chr(128 + (($v &gt;&gt;  6) &amp; 63))
                    . chr(128 + ($v &amp; 63));
            } else if ($v &lt; 1 &lt;&lt; 26) {
                // 5 bytes
                $output .= chr(248 + ($v &gt;&gt; 24))
                    . chr(128 + (($v &gt;&gt; 18) &amp; 63))
                    . chr(128 + (($v &gt;&gt; 12) &amp; 63))
                    . chr(128 + (($v &gt;&gt;  6) &amp; 63))
                    . chr(128 + ($v &amp; 63));
            } else if ($v &lt; 1 &lt;&lt; 31) {
                // 6 bytes
                $output .= chr(252 + ($v &gt;&gt; 30))
                    . chr(128 + (($v &gt;&gt; 24) &amp; 63))
                    . chr(128 + (($v &gt;&gt; 18) &amp; 63))
                    . chr(128 + (($v &gt;&gt; 12) &amp; 63))
                    . chr(128 + (($v &gt;&gt;  6) &amp; 63))
                    . chr(128 + ($v &amp; 63));
            } else {
                throw new UnexpectedValueException(&#039;Conversion from UCS-4 to UTF-8 failed: malformed input&#039;);
            }
        }

        return $output;
    }

    /**
     * Convert UCS-4 array into UCS-4 string
     *
     * @param array $input ucs4-encoded array
     *
     * @return string      ucs4-encoded string
     * @throws Exception
     * @access private
     */
    private function _ucs4_to_ucs4_string($input)
    {
        $output = &#039;&#039;;
        // Take array values and split output to 4 bytes per value
        // The bit mask is 255, which reads &amp;11111111
        foreach ($input as $v) {
            $output .= ($v &amp; (255 &lt;&lt; 24) &gt;&gt; 24) . ($v &amp; (255 &lt;&lt; 16) &gt;&gt; 16) . ($v &amp; (255 &lt;&lt; 8) &gt;&gt; 8) . ($v &amp; 255);
        }
        return $output;
    }

    /**
     * Convert UCS-4 string into UCS-4 array
     *
     * @param string $input ucs4-encoded string
     *
     * @return array        ucs4-encoded array
     * @throws InvalidArgumentException
     * @access private
     */
    private function _ucs4_string_to_ucs4($input)
    {
        $output = array();

        $inp_len = self::_byteLength($input);
        // Input length must be dividable by 4
        if ($inp_len % 4) {
            throw new InvalidArgumentException(&#039;Input UCS4 string is broken&#039;);
        }

        // Empty input - return empty output
        if (!$inp_len) {
            return $output;
        }

        for ($i = 0, $out_len = -1; $i &lt; $inp_len; ++$i) {
            // Increment output position every 4 input bytes
            if (!$i % 4) {
                $out_len++;
                $output[$out_len] = 0;
            }
            $output[$out_len] += ord($input{$i}) &lt;&lt; (8 * (3 - ($i % 4) ) );
        }
        return $output;
    }

    /**
     * Echo hex representation of UCS4 sequence.
     *
     * @param array   $input       UCS4 sequence
     * @param boolean $include_bit Include bitmask in output
     *
     * @return void
     * @static
     * @access private
     */
    private static function _showHex($input, $include_bit = false)
    {
        foreach ($input as $k =&gt; $v) {
            echo &#039;[&#039;, $k, &#039;] =&gt; &#039;, sprintf(&#039;%X&#039;, $v);

            if ($include_bit) {
                echo &#039; (&#039;, Net_IDNA2::_showBitmask($v), &#039;)&#039;;
            }

            echo &quot;\n&quot;;
        }
    }

    /**
     * Gives you a bit representation of given Byte (8 bits), Word (16 bits) or DWord (32 bits)
     * Output width is automagically determined
     *
     * @param int $octet ...
     *
     * @return string    Bitmask-representation
     * @static
     * @access private
     */
    private static function _showBitmask($octet)
    {
        if ($octet &gt;= (1 &lt;&lt; 16)) {
            $w = 31;
        } else if ($octet &gt;= (1 &lt;&lt; 8)) {
            $w = 15;
        } else {
            $w = 7;
        }

        $return = &#039;&#039;;

        for ($i = $w; $i &gt; -1; $i--) {
            $return .= ($octet &amp; (1 &lt;&lt; $i))? &#039;1&#039; : &#039;0&#039;;
        }

        return $return;
    }

    /**
     * Gets the length of a string in bytes even if mbstring function
     * overloading is turned on
     *
     * @param string $string the string for which to get the length.
     *
     * @return integer the length of the string in bytes.
     *
     * @see Net_IDNA2::$_mb_string_overload
     */
    private static function _byteLength($string)
    {
        if (self::$_mb_string_overload) {
            return mb_strlen($string, &#039;8bit&#039;);
        }
        return strlen((binary)$string);
    }

    // }}}}

    // {{{ factory
    /**
     * Attempts to return a concrete IDNA instance for either php4 or php5.
     *
     * @param array $params Set of paramaters
     *
     * @return Net_IDNA2
     * @access public
     */
    public static function getInstance($params = array())
    {
        return new Net_IDNA2($params);
    }
    // }}}

    // {{{ singleton
    /**
     * Attempts to return a concrete IDNA instance for either php4 or php5,
     * only creating a new instance if no IDNA instance with the same
     * parameters currently exists.
     *
     * @param array $params Set of parameters
     *
     * @return object Net_IDNA2
     * @access public
     */
    public static function singleton($params = array())
    {
        static $instances;
        if (!isset($instances)) {
            $instances = array();
        }

        $signature = serialize($params);
        if (!isset($instances[$signature])) {
            $instances[$signature] = Net_IDNA2::getInstance($params);
        }

        return $instances[$signature];
    }
    // }}}
}

?&gt;
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>