/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/*!

    \class QUrl

    \brief The QUrl class provides a convenient interface for working

    with URLs.

    \reentrant

    \ingroup io

    \ingroup misc

    \ingroup shared

    \mainclass

    It can parse and construct URLs in both encoded and unencoded

    form. QUrl also has support for internationalized domain names

    (IDNs).

    The most common way to use QUrl is to initialize it via the

    constructor by passing a QString. Otherwise, setUrl() and

    setEncodedUrl() can also be used.

    URLs can be represented in two forms: encoded or unencoded. The

    unencoded representation is suitable for showing to users, but

    the encoded representation is typically what you would send to

    a web server. For example, the unencoded URL

    "http://b\uuml\c{}hler.example.com" would be sent to the server as

    "http://xn--bhler-kva.example.com/List%20of%20applicants.xml".

    A URL can also be constructed piece by piece by calling

    setScheme(), setUserName(), setPassword(), setHost(), setPort(),

    setPath(), setEncodedQuery() and setFragment(). Some convenience

    functions are also available: setAuthority() sets the user name,

    password, host and port. setUserInfo() sets the user name and

    password at once.

    Call isValid() to check if the URL is valid. This can be done at

    any point during the constructing of a URL.

    Constructing a query is particularly convenient through the use

    of setQueryItems(), addQueryItem() and removeQueryItem(). Use

    setQueryDelimiters() to customize the delimiters used for

    generating the query string.

    For the convenience of generating encoded URL strings or query

    strings, there are two static functions called

    fromPercentEncoding() and toPercentEncoding() which deal with

    percent encoding and decoding of QStrings.

    Calling isRelative() will tell whether or not the URL is

    relative. A relative URL can be resolved by passing it as argument

    to resolved(), which returns an absolute URL. isParentOf() is used

    for determining whether one URL is a parent of another.

    fromLocalFile() constructs a QUrl by parsing a local

    file path. toLocalFile() converts a URL to a local file path.

    The human readable representation of the URL is fetched with

    toString(). This representation is appropriate for displaying a

    URL to a user in unencoded form. The encoded form however, as

    returned by toEncoded(), is for internal use, passing to web

    servers, mail clients and so on.

    QUrl conforms to the URI specification from

    \l{RFC 3986} (Uniform Resource Identifier: Generic Syntax), and includes

    scheme extensions from \l{RFC 1738} (Uniform Resource Locators). Case

    folding rules in QUrl conform to \l{RFC 3491} (Nameprep: A Stringprep

    Profile for Internationalized Domain Names (IDN)).

    \sa QUrlInfo

*/

/*!

    \enum QUrl::ParsingMode

    The parsing mode controls the way QUrl parses strings.

    \value TolerantMode QUrl will try to correct some common errors in URLs.

                        This mode is useful when processing URLs entered by

                        users.

    \value StrictMode Only valid URLs are accepted. This mode is useful for

                      general URL validation.

    In TolerantMode, the parser corrects the following invalid input:

    \list

    \o Spaces and "%20": If an encoded URL contains a space, this will be

    replaced with "%20". If a decoded URL contains "%20", this will be

    replaced with a single space before the URL is parsed.

    \o Single "%" characters: Any occurrences of a percent character "%" not

    followed by exactly two hexadecimal characters (e.g., "13% coverage.html")

    will be replaced by "%25".

    \o Reserved and unreserved characters: An encoded URL should only

    contain a few characters as literals; all other characters should

    be percent-encoded. In TolerantMode, these characters will be

    automatically percent-encoded where they are not allowed:

            space / double-quote / "<" / ">" / "[" / "\" /

            "]" / "^" / "`" / "{" / "|" / "}"

    \endlist

*/

/*!

    \enum QUrl::FormattingOption

    The formatting options define how the URL is formatted when written out

    as text.

    \value None The format of the URL is unchanged.

    \value RemoveScheme  The scheme is removed from the URL.

    \value RemovePassword  Any password in the URL is removed.

    \value RemoveUserInfo  Any user information in the URL is removed.

    \value RemovePort      Any specified port is removed from the URL.

    \value RemoveAuthority

    \value RemovePath   The URL's path is removed, leaving only the scheme,

                        host address, and port (if present).

    \value RemoveQuery  The query part of the URL (following a '?' character)

                        is removed.

    \value RemoveFragment

    \value StripTrailingSlash  The trailing slash is removed if one is present.

    Note that the case folding rules in \l{RFC 3491}{Nameprep}, which QUrl

    conforms to, require host names to always be converted to lower case,

    regardless of the Qt::FormattingOptions used.

*/

#include "qplatformdefs.h"

#include "qurl.h"

#include "private/qunicodetables_p.h"

#include "qatomic.h"

#include "qbytearray.h"

#include "qlist.h"

#ifndef QT_NO_REGEXP

#include "qregexp.h"

#endif

#include "qstring.h"

#include "qstringlist.h"

#include "qstack.h"

#include "qvarlengtharray.h"

#include "qdebug.h"

#if defined QT3_SUPPORT

#include "qfileinfo.h"

#endif

#if defined(Q_OS_WINCE_WM)

#pragma optimize("g", off)

#endif

QT_BEGIN_NAMESPACE

extern void q_normalizePercentEncoding(QByteArray *ba, const char *exclude);

extern void q_toPercentEncoding(QByteArray *ba, const char *exclude, const char *include = 0);

extern void q_fromPercentEncoding(QByteArray *ba);

static QByteArray toPercentEncodingHelper(const QString &s, const char *exclude, const char *include = 0)

{

    if (s.isNull())

        return QByteArray();    // null

    QByteArray ba = s.toUtf8();

    q_toPercentEncoding(&ba, exclude, include);

    return ba;

}

static QString fromPercentEncodingHelper(const QByteArray &ba)

{

    if (ba.isNull())

        return QString();       // null

    QByteArray copy = ba;

    q_fromPercentEncoding(&copy);

    return QString::fromUtf8(copy.constData(), copy.length());

}

static QString fromPercentEncodingMutable(QByteArray *ba)

{

    if (ba->isNull())

        return QString();       // null

    q_fromPercentEncoding(ba);

    return QString::fromUtf8(ba->constData(), ba->length());

}

// ### Qt 5: Consider accepting empty strings as valid. See task 144227.

//#define QURL_DEBUG

// implemented in qvsnprintf.cpp

Q_CORE_EXPORT int qsnprintf(char *str, size_t n, const char *fmt, ...);

// needed by the punycode encoder/decoder

#define Q_MAXINT ((uint)((uint)(-1)>>1))

static const uint base = 36;

static const uint tmin = 1;

static const uint tmax = 26;

static const uint skew = 38;

static const uint damp = 700;

static const uint initial_bias = 72;

static const uint initial_n = 128;

#define QURL_SETFLAG(a, b) { (a) |= (b); }

#define QURL_UNSETFLAG(a, b) { (a) &= ~(b); }

#define QURL_HASFLAG(a, b) (((a) & (b)) == (b))

struct QUrlErrorInfo {

    inline QUrlErrorInfo() : _source(0), _message(0), _expected(0), _found(0)

    { }

    const char *_source;

    const char *_message;

    char _expected;

    char _found;

    inline void setParams(const char *source, const char *message, char expected, char found)

    {

        _source = source;

        _message = message;

        _expected = expected;

        _found = found;

    }

};

struct QUrlParseData

{

    const char *scheme;

    int schemeLength;

    const char *userInfo;

    int userInfoDelimIndex;

    int userInfoLength;

    const char *host;

    int hostLength;

    int port;

    const char *path;

    int pathLength;

    const char *query;

    int queryLength;

    const char *fragment;

    int fragmentLength;

};

class QUrlPrivate

{

public:

    QUrlPrivate();

    QUrlPrivate(const QUrlPrivate &other);

    bool setUrl(const QString &url);

    QString canonicalHost() const;

    void ensureEncodedParts() const;

    QString authority(QUrl::FormattingOptions options = QUrl::None) const;

    void setAuthority(const QString &auth);

    void setUserInfo(const QString &userInfo);

    QString userInfo(QUrl::FormattingOptions options = QUrl::None) const;

    void setEncodedAuthority(const QByteArray &authority);

    void setEncodedUserInfo(const QUrlParseData *parseData);

    QByteArray mergePaths(const QByteArray &relativePath) const;

    void queryItem(int pos, int *value, int *end);

    enum ParseOptions {

        ParseAndSet,

        ParseOnly

    };

    void validate() const;

    void parse(ParseOptions parseOptions = ParseAndSet) const;

    void clear();

    QByteArray toEncoded(QUrl::FormattingOptions options = QUrl::None) const;

    QAtomicInt ref;

    QString scheme;

    QString userName;

    QString password;

    QString host;

    QString path;

    QByteArray query;

    QString fragment;

    QByteArray encodedOriginal;

    QByteArray encodedUserName;

    QByteArray encodedPassword;

    QByteArray encodedPath;

    QByteArray encodedFragment;

    int port;

    QUrl::ParsingMode parsingMode;

    bool hasQuery;

    bool hasFragment;

    bool isValid;

    char valueDelimiter;

    char pairDelimiter;

    enum State {

        Parsed = 0x1,

        Validated = 0x2,

        Normalized = 0x4,

        HostCanonicalized = 0x8

    };

    int stateFlags;

    QByteArray encodedNormalized;

    const QByteArray & normalized();

    mutable QUrlErrorInfo errorInfo;

    QString createErrorString();

};

static bool QT_FASTCALL _HEXDIG(const char **ptr)

{

    char ch = **ptr;

    if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) {

        ++(*ptr);

        return true;

    }

    return false;

}

// pct-encoded = "%" HEXDIG HEXDIG

static bool QT_FASTCALL _pctEncoded(const char **ptr)

{

    const char *ptrBackup = *ptr;

    if (**ptr != '%')

        return false;

    ++(*ptr);

    if (!_HEXDIG(ptr)) {

        *ptr = ptrBackup;

        return false;

    }

    if (!_HEXDIG(ptr)) {

        *ptr = ptrBackup;

        return false;

    }

    return true;

}

#if 0

// gen-delims  = ":" / "/" / "?" / "#" / "[" / "]" / "@"

static bool QT_FASTCALL _genDelims(const char **ptr, char *c)

{

    char ch = **ptr;

    switch (ch) {

    case ':': case '/': case '?': case '#':

    case '[': case ']': case '@':

        *c = ch;

        ++(*ptr);

        return true;

    default:

        return false;

    }

}

#endif

// sub-delims  = "!" / "$" / "&" / "'" / "(" / ")"

//             / "*" / "+" / "," / ";" / "="

static bool QT_FASTCALL _subDelims(const char **ptr)

{

    char ch = **ptr;

    switch (ch) {

    case '!': case '$': case '&': case '\'':

    case '(': case ')': case '*': case '+':

    case ',': case ';': case '=':

        ++(*ptr);

        return true;

    default:

        return false;

    }

}

// unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"

static bool QT_FASTCALL _unreserved(const char **ptr)

{

    char ch = **ptr;

    if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')

        || (ch >= '0' && ch <= '9')

        || ch == '-' || ch == '.' || ch == '_' || ch == '~') {

        ++(*ptr);

        return true;

    } 

    return false;

}

// scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

static void QT_FASTCALL _scheme(const char **ptr, QUrlParseData *parseData)

{

    bool first = true;

    parseData->scheme = *ptr;

    for (;;) {

        char ch = **ptr;

        if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {

            ;

        } else if (!first && ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')) {

            ;

        } else {

            break;

        }

        ++(*ptr);

        first = false;

    }

    if (**ptr != ':') {

        *ptr = parseData->scheme;

    } else {

        parseData->schemeLength = *ptr - parseData->scheme;

        ++(*ptr); // skip ':'

    }

}

// IPvFuture  = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )

static bool QT_FASTCALL _IPvFuture(const char **ptr)

{

    if (**ptr != 'v')

        return false;

    const char *ptrBackup = *ptr;

    ++(*ptr);

    if (!_HEXDIG(ptr)) {

        *ptr = ptrBackup;

        return false;

    }

    while (_HEXDIG(ptr))

        ;

    if (**ptr != '.') {

        *ptr = ptrBackup;

        return false;

    }

    ++(*ptr);

    if (!_unreserved(ptr) && !_subDelims(ptr) && *((*ptr)++) != ':') {

        *ptr = ptrBackup;

        return false;

    }

    while (_unreserved(ptr) || _subDelims(ptr) || *((*ptr)++) == ':')

        ;

    return true;

}

// h16         = 1*4HEXDIG

//             ; 16 bits of address represented in hexadecimal

static bool QT_FASTCALL _h16(const char **ptr)

{

    int i = 0;

    for (; i < 4; ++i) {

        if (!_HEXDIG(ptr))

            break;

    }

    return (i != 0);

}

// dec-octet   = DIGIT                 ; 0-9

//             / %x31-39 DIGIT         ; 10-99

//             / "1" 2DIGIT            ; 100-199

//             / "2" %x30-34 DIGIT     ; 200-249

//             / "25" %x30-35          ; 250-255

static bool QT_FASTCALL _decOctet(const char **ptr)

{

    const char *ptrBackup = *ptr;

    char c1 = **ptr;

    if (c1 < '0' || c1 > '9') 

        return false;

    ++(*ptr);

    if (c1 == '0')

        return true;

    char c2 = **ptr;

    if (c2 < '0' || c2 > '9')

        return true;

    ++(*ptr);

    char c3 = **ptr;

    if (c3 < '0' || c3 > '9')

        return true;

    // If there is a three digit number larger than 255, reject the

    // whole token.

    if (c1 >= '2' && c2 >= '5' && c3 > '5') {

        *ptr = ptrBackup;

        return false;

    }

    ++(*ptr);

    return true;

}

// IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet

static bool QT_FASTCALL _IPv4Address(const char **ptr)

{

    const char *ptrBackup = *ptr;

    if (!_decOctet(ptr)) {

        *ptr = ptrBackup;

        return false;

    }

    for (int i = 0; i < 3; ++i) {

        char ch = *((*ptr)++);

        if (ch != '.') {

            *ptr = ptrBackup;

            return false;

        }

        if (!_decOctet(ptr)) {

            *ptr = ptrBackup;

            return false;

        }

    }

    return true;

}

// ls32        = ( h16 ":" h16 ) / IPv4address

//             ; least-significant 32 bits of address

static bool QT_FASTCALL _ls32(const char **ptr)

{

    const char *ptrBackup = *ptr;

    if (_h16(ptr) && *((*ptr)++) == ':' && _h16(ptr)) 

        return true;

    *ptr = ptrBackup;

    return _IPv4Address(ptr);

}

// IPv6address =                            6( h16 ":" ) ls32 // case 1

//             /                       "::" 5( h16 ":" ) ls32 // case 2

//             / [               h16 ] "::" 4( h16 ":" ) ls32 // case 3

//             / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32 // case 4

//             / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32 // case 5

//             / [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32 // case 6

//             / [ *4( h16 ":" ) h16 ] "::"              ls32 // case 7

//             / [ *5( h16 ":" ) h16 ] "::"              h16  // case 8

//             / [ *6( h16 ":" ) h16 ] "::"                   // case 9

static bool QT_FASTCALL _IPv6Address(const char **ptr)

{

    const char *ptrBackup = *ptr;

    // count of (h16 ":") to the left of and including ::

    int leftHexColons = 0;

    // count of (h16 ":") to the right of ::

    int rightHexColons = 0;

    // first count the number of (h16 ":") on the left of ::

    while (_h16(ptr)) {

        // an h16 not followed by a colon is considered an

        // error.

        if (**ptr != ':') {

            *ptr = ptrBackup;

            return false;

        }

        ++(*ptr);

        ++leftHexColons;

        // check for case 1, the only time when there can be no ::

        if (leftHexColons == 6 && _ls32(ptr)) {

            return true;

        }

    }

    // check for case 2 where the address starts with a :

    if (leftHexColons == 0 && *((*ptr)++) != ':') {

        *ptr = ptrBackup;

        return false;

    }

    // check for the second colon in ::

    if (*((*ptr)++) != ':') {

        *ptr = ptrBackup;

        return false;

    }

    int canBeCase = -1;

    bool ls32WasRead = false;

    const char *tmpBackup = *ptr;

    // count the number of (h16 ":") on the right of ::

    for (;;) {

        tmpBackup = *ptr;

        if (!_h16(ptr)) {

            if (!_ls32(ptr)) {

                if (rightHexColons != 0) {

                    *ptr = ptrBackup;

                    return false;

                }

                // the address ended with :: (case 9)

                // only valid if 1 <= leftHexColons <= 7

                canBeCase = 9;

            } else {

                ls32WasRead = true;

            }

            break;

        }

        ++rightHexColons;

        if (**ptr != ':') {

            // no colon could mean that what was read as an h16

            // was in fact the first part of an ls32. we backtrack

            // and retry.

            const char *pb = *ptr;

            *ptr = tmpBackup;

            if (_ls32(ptr)) {

                ls32WasRead = true;

                --rightHexColons;

            } else {

                *ptr = pb;

                // address ends with only 1 h16 after :: (case 8)

                if (rightHexColons == 1)

                    canBeCase = 8;

            }

            break;

        }

        ++(*ptr);

    }

    // determine which case it is based on the number of rightHexColons

    if (canBeCase == -1) {

        // check if a ls32 was read. If it wasn't and rightHexColons >= 2 then the

        // last 2 HexColons are in fact a ls32

        if (!ls32WasRead && rightHexColons >= 2)

            rightHexColons -= 2;

        canBeCase = 7 - rightHexColons;

    }

    // based on the case we need to check that the number of leftHexColons is valid

    if (leftHexColons > (canBeCase - 2)) {

        *ptr = ptrBackup;

        return false;

    }

    return true;

}

// IP-literal = "[" ( IPv6address / IPvFuture  ) "]"

static bool QT_FASTCALL _IPLiteral(const char **ptr)

{

    const char *ptrBackup = *ptr;

    if (**ptr != '[')

        return false;

    ++(*ptr);

    if (!_IPv6Address(ptr) && !_IPvFuture(ptr)) {

        *ptr = ptrBackup;

        return false;

    }

    if (**ptr != ']') {

        *ptr = ptrBackup;

        return false;

    }

    ++(*ptr);

    return true;

}

// reg-name    = *( unreserved / pct-encoded / sub-delims )

static void QT_FASTCALL _regName(const char **ptr)

{

    for (;;) {

        if (!_unreserved(ptr) && !_subDelims(ptr)) {

            if (!_pctEncoded(ptr))

                break;

        }

    }

}

// host        = IP-literal / IPv4address / reg-name

static void QT_FASTCALL _host(const char **ptr, QUrlParseData *parseData)

{

    parseData->host = *ptr;

    if (!_IPLiteral(ptr)) {

        if (_IPv4Address(ptr)) {

            char ch = **ptr;

            if (ch && ch != ':' && ch != '/') {

                // reset

                *ptr = parseData->host;

                _regName(ptr);

            }

        } else {

            _regName(ptr);

        }

    }

    parseData->hostLength = *ptr - parseData->host;

}

// userinfo    = *( unreserved / pct-encoded / sub-delims / ":" )

static void QT_FASTCALL _userInfo(const char **ptr, QUrlParseData *parseData)

{

    parseData->userInfo = *ptr;

    for (;;) {

        if (_unreserved(ptr) || _subDelims(ptr)) {

            ;

        } else {

            if (_pctEncoded(ptr)) {

                ;

            } else if (**ptr == ':') {

                parseData->userInfoDelimIndex = *ptr - parseData->userInfo;

                ++(*ptr);

            } else {

                break;

            }

        }

    }

    if (**ptr != '@') {

        *ptr = parseData->userInfo;

        parseData->userInfoDelimIndex = -1;

        return;

    }

    parseData->userInfoLength = *ptr - parseData->userInfo;

    ++(*ptr);

}

// port        = *DIGIT

static void QT_FASTCALL _port(const char **ptr, int *port)

{

    bool first = true;

    for (;;) {

        const char *ptrBackup = *ptr;

        char ch = *((*ptr)++);

        if (ch < '0' || ch > '9') {

            *ptr = ptrBackup;

            break;

        }

        if (first) {

            first = false;

            *port = 0;

        }

        *port *= 10;

        *port += ch - '0';

    }

}

// authority   = [ userinfo "@" ] host [ ":" port ]

static void QT_FASTCALL _authority(const char **ptr, QUrlParseData *parseData)

{

    _userInfo(ptr, parseData);

    _host(ptr, parseData);

    if (**ptr != ':') 

        return;

    ++(*ptr);

    _port(ptr, &parseData->port);

}

// pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"

static bool QT_FASTCALL _pchar(const char **ptr)

{

    char c = *(*ptr);

    switch (c) {

    case '!': case '$': case '&': case '\'': case '(': case ')': case '*':

    case '+': case ',': case ';': case '=': case ':': case '@':

    case '-': case '.': case '_': case '~':

        ++(*ptr);

        return true;

    default:

        break;

    };

    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) {

        ++(*ptr);

        return true;

    }

    if (_pctEncoded(ptr))

        return true;

    return false;

}

// segment       = *pchar

static bool QT_FASTCALL _segmentNZ(const char **ptr)

{

    if (!_pchar(ptr))

        return false;

    while(_pchar(ptr))

        ;

    return true;

}

// path-abempty  = *( "/" segment )

static void QT_FASTCALL _pathAbEmpty(const char **ptr)

{

    for (;;) {

        if (**ptr != '/') 

            break;

        ++(*ptr);

        while (_pchar(ptr))

            ;

    }

}

// path-abs      = "/" [ segment-nz *( "/" segment ) ]

static bool QT_FASTCALL _pathAbs(const char **ptr)

{

    // **ptr == '/' already checked in caller

    ++(*ptr);

    // we might be able to unnest this to gain some performance.

    if (!_segmentNZ(ptr))

        return true;

    _pathAbEmpty(ptr);

    return true;

}

// path-rootless = segment-nz *( "/" segment )

static bool QT_FASTCALL _pathRootless(const char **ptr)

{

    // we might be able to unnest this to gain some performance.

    if (!_segmentNZ(ptr))

        return false;

    _pathAbEmpty(ptr);

    return true;

}

// hier-part   = "//" authority path-abempty

//             / path-abs

//             / path-rootless

//             / path-empty

static void QT_FASTCALL _hierPart(const char **ptr, QUrlParseData *parseData)

{

    const char *ptrBackup = *ptr;

    const char *pathStart = 0;

    if (*((*ptr)++) == '/' && *((*ptr)++) == '/') {

        _authority(ptr, parseData);

        pathStart = *ptr;

        _pathAbEmpty(ptr);

    } else {

        *ptr = ptrBackup;

        pathStart = *ptr;

        if (**ptr == '/')

            _pathAbs(ptr);

        else

            _pathRootless(ptr);

    }

    parseData->path = pathStart;

    parseData->pathLength = *ptr - pathStart;

}

// query       = *( pchar / "/" / "?" )

static void QT_FASTCALL _query(const char **ptr, QUrlParseData *parseData)

{

    parseData->query = *ptr;

    for (;;) {

        if (_pchar(ptr)) {

            ;

        } else if (**ptr == '/' || **ptr == '?') {

            ++(*ptr);

        } else {

            break;

        }

    }

    parseData->queryLength = *ptr - parseData->query;

}

// fragment    = *( pchar / "/" / "?" )

static void QT_FASTCALL _fragment(const char **ptr, QUrlParseData *parseData)

{

    parseData->fragment = *ptr;

    for (;;) {

        if (_pchar(ptr)) {

            ;

        } else if (**ptr == '/' || **ptr == '?' || **ptr == '#') {

            ++(*ptr);

        } else {

            break;

        }

    }

    parseData->fragmentLength = *ptr - parseData->fragment;

}

struct NameprepCaseFoldingEntry {

    int uc;

    ushort mapping[4];

};

inline bool operator<(int one, const NameprepCaseFoldingEntry &other)

{ return one < other.uc; }

inline bool operator<(const NameprepCaseFoldingEntry &one, int other)

{ return one.uc < other; }

static const NameprepCaseFoldingEntry NameprepCaseFolding[] = {

/*	{ 0x0041, { 0x0061, 0x0000, 0x0000, 0x0000 } },

	{ 0x0042, { 0x0062, 0x0000, 0x0000, 0x0000 } },

	{ 0x0043, { 0x0063, 0x0000, 0x0000, 0x0000 } },

	{ 0x0044, { 0x0064, 0x0000, 0x0000, 0x0000 } },

	{ 0x0045, { 0x0065, 0x0000, 0x0000, 0x0000 } },

	{ 0x0046, { 0x0066, 0x0000, 0x0000, 0x0000 } },

	{ 0x0047, { 0x0067, 0x0000, 0x0000, 0x0000 } },

	{ 0x0048, { 0x0068, 0x0000, 0x0000, 0x0000 } },

	{ 0x0049, { 0x0069, 0x0000, 0x0000, 0x0000 } },

	{ 0x004A, { 0x006A, 0x0000, 0x0000, 0x0000 } },

	{ 0x004B, { 0x006B, 0x0000, 0x0000, 0x0000 } },

	{ 0x004C, { 0x006C, 0x0000, 0x0000, 0x0000 } },

	{ 0x004D, { 0x006D, 0x0000, 0x0000, 0x0000 } },

	{ 0x004E, { 0x006E, 0x0000, 0x0000, 0x0000 } },

	{ 0x004F, { 0x006F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0050, { 0x0070, 0x0000, 0x0000, 0x0000 } },

	{ 0x0051, { 0x0071, 0x0000, 0x0000, 0x0000 } },

	{ 0x0052, { 0x0072, 0x0000, 0x0000, 0x0000 } },

	{ 0x0053, { 0x0073, 0x0000, 0x0000, 0x0000 } },

	{ 0x0054, { 0x0074, 0x0000, 0x0000, 0x0000 } },

	{ 0x0055, { 0x0075, 0x0000, 0x0000, 0x0000 } },

	{ 0x0056, { 0x0076, 0x0000, 0x0000, 0x0000 } },

	{ 0x0057, { 0x0077, 0x0000, 0x0000, 0x0000 } },

	{ 0x0058, { 0x0078, 0x0000, 0x0000, 0x0000 } },

	{ 0x0059, { 0x0079, 0x0000, 0x0000, 0x0000 } },

	{ 0x005A, { 0x007A, 0x0000, 0x0000, 0x0000 } },*/

	{ 0x00B5, { 0x03BC, 0x0000, 0x0000, 0x0000 } },

	{ 0x00C0, { 0x00E0, 0x0000, 0x0000, 0x0000 } },

	{ 0x00C1, { 0x00E1, 0x0000, 0x0000, 0x0000 } },

	{ 0x00C2, { 0x00E2, 0x0000, 0x0000, 0x0000 } },

	{ 0x00C3, { 0x00E3, 0x0000, 0x0000, 0x0000 } },

	{ 0x00C4, { 0x00E4, 0x0000, 0x0000, 0x0000 } },

	{ 0x00C5, { 0x00E5, 0x0000, 0x0000, 0x0000 } },

	{ 0x00C6, { 0x00E6, 0x0000, 0x0000, 0x0000 } },

	{ 0x00C7, { 0x00E7, 0x0000, 0x0000, 0x0000 } },

	{ 0x00C8, { 0x00E8, 0x0000, 0x0000, 0x0000 } },

	{ 0x00C9, { 0x00E9, 0x0000, 0x0000, 0x0000 } },

	{ 0x00CA, { 0x00EA, 0x0000, 0x0000, 0x0000 } },

	{ 0x00CB, { 0x00EB, 0x0000, 0x0000, 0x0000 } },

	{ 0x00CC, { 0x00EC, 0x0000, 0x0000, 0x0000 } },

	{ 0x00CD, { 0x00ED, 0x0000, 0x0000, 0x0000 } },

	{ 0x00CE, { 0x00EE, 0x0000, 0x0000, 0x0000 } },

	{ 0x00CF, { 0x00EF, 0x0000, 0x0000, 0x0000 } },

	{ 0x00D0, { 0x00F0, 0x0000, 0x0000, 0x0000 } },

	{ 0x00D1, { 0x00F1, 0x0000, 0x0000, 0x0000 } },

	{ 0x00D2, { 0x00F2, 0x0000, 0x0000, 0x0000 } },

	{ 0x00D3, { 0x00F3, 0x0000, 0x0000, 0x0000 } },

	{ 0x00D4, { 0x00F4, 0x0000, 0x0000, 0x0000 } },

	{ 0x00D5, { 0x00F5, 0x0000, 0x0000, 0x0000 } },

	{ 0x00D6, { 0x00F6, 0x0000, 0x0000, 0x0000 } },

	{ 0x00D8, { 0x00F8, 0x0000, 0x0000, 0x0000 } },

	{ 0x00D9, { 0x00F9, 0x0000, 0x0000, 0x0000 } },

	{ 0x00DA, { 0x00FA, 0x0000, 0x0000, 0x0000 } },

	{ 0x00DB, { 0x00FB, 0x0000, 0x0000, 0x0000 } },

	{ 0x00DC, { 0x00FC, 0x0000, 0x0000, 0x0000 } },

	{ 0x00DD, { 0x00FD, 0x0000, 0x0000, 0x0000 } },

	{ 0x00DE, { 0x00FE, 0x0000, 0x0000, 0x0000 } },

	{ 0x00DF, { 0x0073, 0x0073, 0x0000, 0x0000 } },

	{ 0x0100, { 0x0101, 0x0000, 0x0000, 0x0000 } },

	{ 0x0102, { 0x0103, 0x0000, 0x0000, 0x0000 } },

	{ 0x0104, { 0x0105, 0x0000, 0x0000, 0x0000 } },

	{ 0x0106, { 0x0107, 0x0000, 0x0000, 0x0000 } },

	{ 0x0108, { 0x0109, 0x0000, 0x0000, 0x0000 } },

	{ 0x010A, { 0x010B, 0x0000, 0x0000, 0x0000 } },

	{ 0x010C, { 0x010D, 0x0000, 0x0000, 0x0000 } },

	{ 0x010E, { 0x010F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0110, { 0x0111, 0x0000, 0x0000, 0x0000 } },

	{ 0x0112, { 0x0113, 0x0000, 0x0000, 0x0000 } },

	{ 0x0114, { 0x0115, 0x0000, 0x0000, 0x0000 } },

	{ 0x0116, { 0x0117, 0x0000, 0x0000, 0x0000 } },

	{ 0x0118, { 0x0119, 0x0000, 0x0000, 0x0000 } },

	{ 0x011A, { 0x011B, 0x0000, 0x0000, 0x0000 } },

	{ 0x011C, { 0x011D, 0x0000, 0x0000, 0x0000 } },

	{ 0x011E, { 0x011F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0120, { 0x0121, 0x0000, 0x0000, 0x0000 } },

	{ 0x0122, { 0x0123, 0x0000, 0x0000, 0x0000 } },

	{ 0x0124, { 0x0125, 0x0000, 0x0000, 0x0000 } },

	{ 0x0126, { 0x0127, 0x0000, 0x0000, 0x0000 } },

	{ 0x0128, { 0x0129, 0x0000, 0x0000, 0x0000 } },

	{ 0x012A, { 0x012B, 0x0000, 0x0000, 0x0000 } },

	{ 0x012C, { 0x012D, 0x0000, 0x0000, 0x0000 } },

	{ 0x012E, { 0x012F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0130, { 0x0069, 0x0307, 0x0000, 0x0000 } },

	{ 0x0132, { 0x0133, 0x0000, 0x0000, 0x0000 } },

	{ 0x0134, { 0x0135, 0x0000, 0x0000, 0x0000 } },

	{ 0x0136, { 0x0137, 0x0000, 0x0000, 0x0000 } },

	{ 0x0139, { 0x013A, 0x0000, 0x0000, 0x0000 } },

	{ 0x013B, { 0x013C, 0x0000, 0x0000, 0x0000 } },

	{ 0x013D, { 0x013E, 0x0000, 0x0000, 0x0000 } },

	{ 0x013F, { 0x0140, 0x0000, 0x0000, 0x0000 } },

	{ 0x0141, { 0x0142, 0x0000, 0x0000, 0x0000 } },

	{ 0x0143, { 0x0144, 0x0000, 0x0000, 0x0000 } },

	{ 0x0145, { 0x0146, 0x0000, 0x0000, 0x0000 } },

	{ 0x0147, { 0x0148, 0x0000, 0x0000, 0x0000 } },

	{ 0x0149, { 0x02BC, 0x006E, 0x0000, 0x0000 } },

	{ 0x014A, { 0x014B, 0x0000, 0x0000, 0x0000 } },

	{ 0x014C, { 0x014D, 0x0000, 0x0000, 0x0000 } },

	{ 0x014E, { 0x014F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0150, { 0x0151, 0x0000, 0x0000, 0x0000 } },

	{ 0x0152, { 0x0153, 0x0000, 0x0000, 0x0000 } },

	{ 0x0154, { 0x0155, 0x0000, 0x0000, 0x0000 } },

	{ 0x0156, { 0x0157, 0x0000, 0x0000, 0x0000 } },

	{ 0x0158, { 0x0159, 0x0000, 0x0000, 0x0000 } },

	{ 0x015A, { 0x015B, 0x0000, 0x0000, 0x0000 } },

	{ 0x015C, { 0x015D, 0x0000, 0x0000, 0x0000 } },

	{ 0x015E, { 0x015F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0160, { 0x0161, 0x0000, 0x0000, 0x0000 } },

	{ 0x0162, { 0x0163, 0x0000, 0x0000, 0x0000 } },

	{ 0x0164, { 0x0165, 0x0000, 0x0000, 0x0000 } },

	{ 0x0166, { 0x0167, 0x0000, 0x0000, 0x0000 } },

	{ 0x0168, { 0x0169, 0x0000, 0x0000, 0x0000 } },

	{ 0x016A, { 0x016B, 0x0000, 0x0000, 0x0000 } },

	{ 0x016C, { 0x016D, 0x0000, 0x0000, 0x0000 } },

	{ 0x016E, { 0x016F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0170, { 0x0171, 0x0000, 0x0000, 0x0000 } },

	{ 0x0172, { 0x0173, 0x0000, 0x0000, 0x0000 } },

	{ 0x0174, { 0x0175, 0x0000, 0x0000, 0x0000 } },

	{ 0x0176, { 0x0177, 0x0000, 0x0000, 0x0000 } },

	{ 0x0178, { 0x00FF, 0x0000, 0x0000, 0x0000 } },

	{ 0x0179, { 0x017A, 0x0000, 0x0000, 0x0000 } },

	{ 0x017B, { 0x017C, 0x0000, 0x0000, 0x0000 } },

	{ 0x017D, { 0x017E, 0x0000, 0x0000, 0x0000 } },

	{ 0x017F, { 0x0073, 0x0000, 0x0000, 0x0000 } },

	{ 0x0181, { 0x0253, 0x0000, 0x0000, 0x0000 } },

	{ 0x0182, { 0x0183, 0x0000, 0x0000, 0x0000 } },

	{ 0x0184, { 0x0185, 0x0000, 0x0000, 0x0000 } },

	{ 0x0186, { 0x0254, 0x0000, 0x0000, 0x0000 } },

	{ 0x0187, { 0x0188, 0x0000, 0x0000, 0x0000 } },

	{ 0x0189, { 0x0256, 0x0000, 0x0000, 0x0000 } },

	{ 0x018A, { 0x0257, 0x0000, 0x0000, 0x0000 } },

	{ 0x018B, { 0x018C, 0x0000, 0x0000, 0x0000 } },

	{ 0x018E, { 0x01DD, 0x0000, 0x0000, 0x0000 } },

	{ 0x018F, { 0x0259, 0x0000, 0x0000, 0x0000 } },

	{ 0x0190, { 0x025B, 0x0000, 0x0000, 0x0000 } },

	{ 0x0191, { 0x0192, 0x0000, 0x0000, 0x0000 } },

	{ 0x0193, { 0x0260, 0x0000, 0x0000, 0x0000 } },

	{ 0x0194, { 0x0263, 0x0000, 0x0000, 0x0000 } },

	{ 0x0196, { 0x0269, 0x0000, 0x0000, 0x0000 } },

	{ 0x0197, { 0x0268, 0x0000, 0x0000, 0x0000 } },

	{ 0x0198, { 0x0199, 0x0000, 0x0000, 0x0000 } },

	{ 0x019C, { 0x026F, 0x0000, 0x0000, 0x0000 } },

	{ 0x019D, { 0x0272, 0x0000, 0x0000, 0x0000 } },

	{ 0x019F, { 0x0275, 0x0000, 0x0000, 0x0000 } },

	{ 0x01A0, { 0x01A1, 0x0000, 0x0000, 0x0000 } },

	{ 0x01A2, { 0x01A3, 0x0000, 0x0000, 0x0000 } },

	{ 0x01A4, { 0x01A5, 0x0000, 0x0000, 0x0000 } },

	{ 0x01A6, { 0x0280, 0x0000, 0x0000, 0x0000 } },

	{ 0x01A7, { 0x01A8, 0x0000, 0x0000, 0x0000 } },

	{ 0x01A9, { 0x0283, 0x0000, 0x0000, 0x0000 } },

	{ 0x01AC, { 0x01AD, 0x0000, 0x0000, 0x0000 } },

	{ 0x01AE, { 0x0288, 0x0000, 0x0000, 0x0000 } },

	{ 0x01AF, { 0x01B0, 0x0000, 0x0000, 0x0000 } },

	{ 0x01B1, { 0x028A, 0x0000, 0x0000, 0x0000 } },

	{ 0x01B2, { 0x028B, 0x0000, 0x0000, 0x0000 } },

	{ 0x01B3, { 0x01B4, 0x0000, 0x0000, 0x0000 } },

	{ 0x01B5, { 0x01B6, 0x0000, 0x0000, 0x0000 } },

	{ 0x01B7, { 0x0292, 0x0000, 0x0000, 0x0000 } },

	{ 0x01B8, { 0x01B9, 0x0000, 0x0000, 0x0000 } },

	{ 0x01BC, { 0x01BD, 0x0000, 0x0000, 0x0000 } },

	{ 0x01C4, { 0x01C6, 0x0000, 0x0000, 0x0000 } },

	{ 0x01C5, { 0x01C6, 0x0000, 0x0000, 0x0000 } },

	{ 0x01C7, { 0x01C9, 0x0000, 0x0000, 0x0000 } },

	{ 0x01C8, { 0x01C9, 0x0000, 0x0000, 0x0000 } },

	{ 0x01CA, { 0x01CC, 0x0000, 0x0000, 0x0000 } },

	{ 0x01CB, { 0x01CC, 0x0000, 0x0000, 0x0000 } },

	{ 0x01CD, { 0x01CE, 0x0000, 0x0000, 0x0000 } },

	{ 0x01CF, { 0x01D0, 0x0000, 0x0000, 0x0000 } },

	{ 0x01D1, { 0x01D2, 0x0000, 0x0000, 0x0000 } },

	{ 0x01D3, { 0x01D4, 0x0000, 0x0000, 0x0000 } },

	{ 0x01D5, { 0x01D6, 0x0000, 0x0000, 0x0000 } },

	{ 0x01D7, { 0x01D8, 0x0000, 0x0000, 0x0000 } },

	{ 0x01D9, { 0x01DA, 0x0000, 0x0000, 0x0000 } },

	{ 0x01DB, { 0x01DC, 0x0000, 0x0000, 0x0000 } },

	{ 0x01DE, { 0x01DF, 0x0000, 0x0000, 0x0000 } },

	{ 0x01E0, { 0x01E1, 0x0000, 0x0000, 0x0000 } },

	{ 0x01E2, { 0x01E3, 0x0000, 0x0000, 0x0000 } },

	{ 0x01E4, { 0x01E5, 0x0000, 0x0000, 0x0000 } },

	{ 0x01E6, { 0x01E7, 0x0000, 0x0000, 0x0000 } },

	{ 0x01E8, { 0x01E9, 0x0000, 0x0000, 0x0000 } },

	{ 0x01EA, { 0x01EB, 0x0000, 0x0000, 0x0000 } },

	{ 0x01EC, { 0x01ED, 0x0000, 0x0000, 0x0000 } },

	{ 0x01EE, { 0x01EF, 0x0000, 0x0000, 0x0000 } },

	{ 0x01F0, { 0x006A, 0x030C, 0x0000, 0x0000 } },

	{ 0x01F1, { 0x01F3, 0x0000, 0x0000, 0x0000 } },

	{ 0x01F2, { 0x01F3, 0x0000, 0x0000, 0x0000 } },

	{ 0x01F4, { 0x01F5, 0x0000, 0x0000, 0x0000 } },

	{ 0x01F6, { 0x0195, 0x0000, 0x0000, 0x0000 } },

	{ 0x01F7, { 0x01BF, 0x0000, 0x0000, 0x0000 } },

	{ 0x01F8, { 0x01F9, 0x0000, 0x0000, 0x0000 } },

	{ 0x01FA, { 0x01FB, 0x0000, 0x0000, 0x0000 } },

	{ 0x01FC, { 0x01FD, 0x0000, 0x0000, 0x0000 } },

	{ 0x01FE, { 0x01FF, 0x0000, 0x0000, 0x0000 } },

	{ 0x0200, { 0x0201, 0x0000, 0x0000, 0x0000 } },

	{ 0x0202, { 0x0203, 0x0000, 0x0000, 0x0000 } },

	{ 0x0204, { 0x0205, 0x0000, 0x0000, 0x0000 } },

	{ 0x0206, { 0x0207, 0x0000, 0x0000, 0x0000 } },

	{ 0x0208, { 0x0209, 0x0000, 0x0000, 0x0000 } },

	{ 0x020A, { 0x020B, 0x0000, 0x0000, 0x0000 } },

	{ 0x020C, { 0x020D, 0x0000, 0x0000, 0x0000 } },

	{ 0x020E, { 0x020F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0210, { 0x0211, 0x0000, 0x0000, 0x0000 } },

	{ 0x0212, { 0x0213, 0x0000, 0x0000, 0x0000 } },

	{ 0x0214, { 0x0215, 0x0000, 0x0000, 0x0000 } },

	{ 0x0216, { 0x0217, 0x0000, 0x0000, 0x0000 } },

	{ 0x0218, { 0x0219, 0x0000, 0x0000, 0x0000 } },

	{ 0x021A, { 0x021B, 0x0000, 0x0000, 0x0000 } },

	{ 0x021C, { 0x021D, 0x0000, 0x0000, 0x0000 } },

	{ 0x021E, { 0x021F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0220, { 0x019E, 0x0000, 0x0000, 0x0000 } },

	{ 0x0222, { 0x0223, 0x0000, 0x0000, 0x0000 } },

	{ 0x0224, { 0x0225, 0x0000, 0x0000, 0x0000 } },

	{ 0x0226, { 0x0227, 0x0000, 0x0000, 0x0000 } },

	{ 0x0228, { 0x0229, 0x0000, 0x0000, 0x0000 } },

	{ 0x022A, { 0x022B, 0x0000, 0x0000, 0x0000 } },

	{ 0x022C, { 0x022D, 0x0000, 0x0000, 0x0000 } },

	{ 0x022E, { 0x022F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0230, { 0x0231, 0x0000, 0x0000, 0x0000 } },

	{ 0x0232, { 0x0233, 0x0000, 0x0000, 0x0000 } },

	{ 0x0345, { 0x03B9, 0x0000, 0x0000, 0x0000 } },

	{ 0x037A, { 0x0020, 0x03B9, 0x0000, 0x0000 } },

	{ 0x0386, { 0x03AC, 0x0000, 0x0000, 0x0000 } },

	{ 0x0388, { 0x03AD, 0x0000, 0x0000, 0x0000 } },

	{ 0x0389, { 0x03AE, 0x0000, 0x0000, 0x0000 } },

	{ 0x038A, { 0x03AF, 0x0000, 0x0000, 0x0000 } },

	{ 0x038C, { 0x03CC, 0x0000, 0x0000, 0x0000 } },

	{ 0x038E, { 0x03CD, 0x0000, 0x0000, 0x0000 } },

	{ 0x038F, { 0x03CE, 0x0000, 0x0000, 0x0000 } },

	{ 0x0390, { 0x03B9, 0x0308, 0x0301, 0x0000 } },

	{ 0x0391, { 0x03B1, 0x0000, 0x0000, 0x0000 } },

	{ 0x0392, { 0x03B2, 0x0000, 0x0000, 0x0000 } },

	{ 0x0393, { 0x03B3, 0x0000, 0x0000, 0x0000 } },

	{ 0x0394, { 0x03B4, 0x0000, 0x0000, 0x0000 } },

	{ 0x0395, { 0x03B5, 0x0000, 0x0000, 0x0000 } },

	{ 0x0396, { 0x03B6, 0x0000, 0x0000, 0x0000 } },

	{ 0x0397, { 0x03B7, 0x0000, 0x0000, 0x0000 } },

	{ 0x0398, { 0x03B8, 0x0000, 0x0000, 0x0000 } },

	{ 0x0399, { 0x03B9, 0x0000, 0x0000, 0x0000 } },

	{ 0x039A, { 0x03BA, 0x0000, 0x0000, 0x0000 } },

	{ 0x039B, { 0x03BB, 0x0000, 0x0000, 0x0000 } },

	{ 0x039C, { 0x03BC, 0x0000, 0x0000, 0x0000 } },

	{ 0x039D, { 0x03BD, 0x0000, 0x0000, 0x0000 } },

	{ 0x039E, { 0x03BE, 0x0000, 0x0000, 0x0000 } },

	{ 0x039F, { 0x03BF, 0x0000, 0x0000, 0x0000 } },

	{ 0x03A0, { 0x03C0, 0x0000, 0x0000, 0x0000 } },

	{ 0x03A1, { 0x03C1, 0x0000, 0x0000, 0x0000 } },

	{ 0x03A3, { 0x03C3, 0x0000, 0x0000, 0x0000 } },

	{ 0x03A4, { 0x03C4, 0x0000, 0x0000, 0x0000 } },

	{ 0x03A5, { 0x03C5, 0x0000, 0x0000, 0x0000 } },

	{ 0x03A6, { 0x03C6, 0x0000, 0x0000, 0x0000 } },

	{ 0x03A7, { 0x03C7, 0x0000, 0x0000, 0x0000 } },

	{ 0x03A8, { 0x03C8, 0x0000, 0x0000, 0x0000 } },

	{ 0x03A9, { 0x03C9, 0x0000, 0x0000, 0x0000 } },

	{ 0x03AA, { 0x03CA, 0x0000, 0x0000, 0x0000 } },

	{ 0x03AB, { 0x03CB, 0x0000, 0x0000, 0x0000 } },

	{ 0x03B0, { 0x03C5, 0x0308, 0x0301, 0x0000 } },

	{ 0x03C2, { 0x03C3, 0x0000, 0x0000, 0x0000 } },

	{ 0x03D0, { 0x03B2, 0x0000, 0x0000, 0x0000 } },

	{ 0x03D1, { 0x03B8, 0x0000, 0x0000, 0x0000 } },

	{ 0x03D2, { 0x03C5, 0x0000, 0x0000, 0x0000 } },

	{ 0x03D3, { 0x03CD, 0x0000, 0x0000, 0x0000 } },

	{ 0x03D4, { 0x03CB, 0x0000, 0x0000, 0x0000 } },

	{ 0x03D5, { 0x03C6, 0x0000, 0x0000, 0x0000 } },

	{ 0x03D6, { 0x03C0, 0x0000, 0x0000, 0x0000 } },

	{ 0x03D8, { 0x03D9, 0x0000, 0x0000, 0x0000 } },

	{ 0x03DA, { 0x03DB, 0x0000, 0x0000, 0x0000 } },

	{ 0x03DC, { 0x03DD, 0x0000, 0x0000, 0x0000 } },

	{ 0x03DE, { 0x03DF, 0x0000, 0x0000, 0x0000 } },

	{ 0x03E0, { 0x03E1, 0x0000, 0x0000, 0x0000 } },

	{ 0x03E2, { 0x03E3, 0x0000, 0x0000, 0x0000 } },

	{ 0x03E4, { 0x03E5, 0x0000, 0x0000, 0x0000 } },

	{ 0x03E6, { 0x03E7, 0x0000, 0x0000, 0x0000 } },

	{ 0x03E8, { 0x03E9, 0x0000, 0x0000, 0x0000 } },

	{ 0x03EA, { 0x03EB, 0x0000, 0x0000, 0x0000 } },

	{ 0x03EC, { 0x03ED, 0x0000, 0x0000, 0x0000 } },

	{ 0x03EE, { 0x03EF, 0x0000, 0x0000, 0x0000 } },

	{ 0x03F0, { 0x03BA, 0x0000, 0x0000, 0x0000 } },

	{ 0x03F1, { 0x03C1, 0x0000, 0x0000, 0x0000 } },

	{ 0x03F2, { 0x03C3, 0x0000, 0x0000, 0x0000 } },

	{ 0x03F4, { 0x03B8, 0x0000, 0x0000, 0x0000 } },

	{ 0x03F5, { 0x03B5, 0x0000, 0x0000, 0x0000 } },

	{ 0x0400, { 0x0450, 0x0000, 0x0000, 0x0000 } },

	{ 0x0401, { 0x0451, 0x0000, 0x0000, 0x0000 } },

	{ 0x0402, { 0x0452, 0x0000, 0x0000, 0x0000 } },

	{ 0x0403, { 0x0453, 0x0000, 0x0000, 0x0000 } },

	{ 0x0404, { 0x0454, 0x0000, 0x0000, 0x0000 } },

	{ 0x0405, { 0x0455, 0x0000, 0x0000, 0x0000 } },

	{ 0x0406, { 0x0456, 0x0000, 0x0000, 0x0000 } },

	{ 0x0407, { 0x0457, 0x0000, 0x0000, 0x0000 } },

	{ 0x0408, { 0x0458, 0x0000, 0x0000, 0x0000 } },

	{ 0x0409, { 0x0459, 0x0000, 0x0000, 0x0000 } },

	{ 0x040A, { 0x045A, 0x0000, 0x0000, 0x0000 } },

	{ 0x040B, { 0x045B, 0x0000, 0x0000, 0x0000 } },

	{ 0x040C, { 0x045C, 0x0000, 0x0000, 0x0000 } },

	{ 0x040D, { 0x045D, 0x0000, 0x0000, 0x0000 } },

	{ 0x040E, { 0x045E, 0x0000, 0x0000, 0x0000 } },

	{ 0x040F, { 0x045F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0410, { 0x0430, 0x0000, 0x0000, 0x0000 } },

	{ 0x0411, { 0x0431, 0x0000, 0x0000, 0x0000 } },

	{ 0x0412, { 0x0432, 0x0000, 0x0000, 0x0000 } },

	{ 0x0413, { 0x0433, 0x0000, 0x0000, 0x0000 } },

	{ 0x0414, { 0x0434, 0x0000, 0x0000, 0x0000 } },

	{ 0x0415, { 0x0435, 0x0000, 0x0000, 0x0000 } },

	{ 0x0416, { 0x0436, 0x0000, 0x0000, 0x0000 } },

	{ 0x0417, { 0x0437, 0x0000, 0x0000, 0x0000 } },

	{ 0x0418, { 0x0438, 0x0000, 0x0000, 0x0000 } },

	{ 0x0419, { 0x0439, 0x0000, 0x0000, 0x0000 } },

	{ 0x041A, { 0x043A, 0x0000, 0x0000, 0x0000 } },

	{ 0x041B, { 0x043B, 0x0000, 0x0000, 0x0000 } },

	{ 0x041C, { 0x043C, 0x0000, 0x0000, 0x0000 } },

	{ 0x041D, { 0x043D, 0x0000, 0x0000, 0x0000 } },

	{ 0x041E, { 0x043E, 0x0000, 0x0000, 0x0000 } },

	{ 0x041F, { 0x043F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0420, { 0x0440, 0x0000, 0x0000, 0x0000 } },

	{ 0x0421, { 0x0441, 0x0000, 0x0000, 0x0000 } },

	{ 0x0422, { 0x0442, 0x0000, 0x0000, 0x0000 } },

	{ 0x0423, { 0x0443, 0x0000, 0x0000, 0x0000 } },

	{ 0x0424, { 0x0444, 0x0000, 0x0000, 0x0000 } },

	{ 0x0425, { 0x0445, 0x0000, 0x0000, 0x0000 } },

	{ 0x0426, { 0x0446, 0x0000, 0x0000, 0x0000 } },

	{ 0x0427, { 0x0447, 0x0000, 0x0000, 0x0000 } },

	{ 0x0428, { 0x0448, 0x0000, 0x0000, 0x0000 } },

	{ 0x0429, { 0x0449, 0x0000, 0x0000, 0x0000 } },

	{ 0x042A, { 0x044A, 0x0000, 0x0000, 0x0000 } },

	{ 0x042B, { 0x044B, 0x0000, 0x0000, 0x0000 } },

	{ 0x042C, { 0x044C, 0x0000, 0x0000, 0x0000 } },

	{ 0x042D, { 0x044D, 0x0000, 0x0000, 0x0000 } },

	{ 0x042E, { 0x044E, 0x0000, 0x0000, 0x0000 } },

	{ 0x042F, { 0x044F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0460, { 0x0461, 0x0000, 0x0000, 0x0000 } },

	{ 0x0462, { 0x0463, 0x0000, 0x0000, 0x0000 } },

	{ 0x0464, { 0x0465, 0x0000, 0x0000, 0x0000 } },

	{ 0x0466, { 0x0467, 0x0000, 0x0000, 0x0000 } },

	{ 0x0468, { 0x0469, 0x0000, 0x0000, 0x0000 } },

	{ 0x046A, { 0x046B, 0x0000, 0x0000, 0x0000 } },

	{ 0x046C, { 0x046D, 0x0000, 0x0000, 0x0000 } },

	{ 0x046E, { 0x046F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0470, { 0x0471, 0x0000, 0x0000, 0x0000 } },

	{ 0x0472, { 0x0473, 0x0000, 0x0000, 0x0000 } },

	{ 0x0474, { 0x0475, 0x0000, 0x0000, 0x0000 } },

	{ 0x0476, { 0x0477, 0x0000, 0x0000, 0x0000 } },

	{ 0x0478, { 0x0479, 0x0000, 0x0000, 0x0000 } },

	{ 0x047A, { 0x047B, 0x0000, 0x0000, 0x0000 } },

	{ 0x047C, { 0x047D, 0x0000, 0x0000, 0x0000 } },

	{ 0x047E, { 0x047F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0480, { 0x0481, 0x0000, 0x0000, 0x0000 } },

	{ 0x048A, { 0x048B, 0x0000, 0x0000, 0x0000 } },

	{ 0x048C, { 0x048D, 0x0000, 0x0000, 0x0000 } },

	{ 0x048E, { 0x048F, 0x0000, 0x0000, 0x0000 } },

	{ 0x0490, { 0x0491, 0x0000, 0x0000, 0x0000 } },

	{ 0x0492, { 0x0493, 0x0000, 0x0000, 0x0000 } },

	{ 0x0494, { 0x0495, 0x0000, 0x0000, 0x0000 } },

	{ 0x0496, { 0x0497, 0x0000, 0x0000, 0x0000 } },

	{ 0x0498, { 0x0499, 0x0000, 0x0000, 0x0000 } },

	{ 0x049A, { 0x049B, 0x0000, 0x0000, 0x0000 } },

	{ 0x049C, { 0x049D, 0x0000, 0x0000, 0x0000 } },

	{ 0x049E, { 0x049F, 0x0000, 0x0000, 0x0000 } },