update qmake to 1.05a

31 files changed, 1115 insertions, 678 deletions

diff --git a/qmake/tools/qbitarray.cpp b/qmake/tools/qbitarray.cpp
index 4f4e14b..1aaf963 100644
--- a/qmake/tools/qbitarray.cpp
+++ b/qmake/tools/qbitarray.cpp
@@ -1,661 +1,662 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QBitArray class
 **
 ** Created : 940118
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qbitarray.h"
 #include "qdatastream.h"
 
 #define SHBLOCK	 ((bitarr_data*)(sharedBlock()))
 
 
 /*!
     \class QBitVal qbitarray.h
     \reentrant
     \brief The QBitVal class is an internal class, used with QBitArray.
 
     \ingroup collection
 
     The QBitVal is required by the indexing [] operator on bit arrays.
     It is not for use in any other context.
 */
 
 /*!
     \fn QBitVal::QBitVal (QBitArray* a, uint i)
 
     Constructs a reference to element \a i in the QBitArray \a a.
     This is what QBitArray::operator[] constructs its return value
     with.
 */
 
 /*!
     \fn QBitVal::operator int()
 
     Returns the value referenced by the QBitVal.
 */
 
 /*!
     \fn QBitVal& QBitVal::operator= (const QBitVal& v)
 
     Sets the value referenced by the QBitVal to that referenced by
     QBitVal \a v.
 */
 
 /*!
     \overload QBitVal& QBitVal::operator= (bool v)
 
     Sets the value referenced by the QBitVal to \a v.
 */
 
 
 /*!
     \class QBitArray qbitarray.h
     \reentrant
     \brief The QBitArray class provides an array of bits.
 
     \ingroup collection
     \ingroup tools
     \ingroup shared
 
     Because QBitArray is a QMemArray, it uses explicit \link
     shclass.html sharing\endlink with a reference count.
 
     A QBitArray is a special byte array that can access individual
     bits and perform bit-operations (AND, OR, XOR and NOT) on entire
     arrays or bits.
 
     Bits can be manipulated by the setBit() and clearBit() functions,
     but it is also possible to use the indexing [] operator to test
     and set individual bits. The [] operator is a little slower than
     setBit() and clearBit() because some tricks are required to
     implement single-bit assignments.
 
     Example:
     \code
     QBitArray a(3);
     a.setBit( 0 );
     a.clearBit( 1 );
     a.setBit( 2 );     // a = [1 0 1]
 
     QBitArray b(3);
     b[0] = 1;
     b[1] = 1;
     b[2] = 0;          // b = [1 1 0]
 
     QBitArray c;
     c = ~a & b;        // c = [0 1 0]
     \endcode
 
     When a QBitArray is constructed the bits are uninitialized. Use
     fill() to set all the bits to 0 or 1. The array can be resized
     with resize() and copied with copy(). Bits can be set with
     setBit() and cleared with clearBit(). Bits can be toggled with
     toggleBit(). A bit's value can be obtained with testBit() and with
     at().
 
     QBitArray supports the \& (AND), | (OR), ^ (XOR) and ~ (NOT)
     operators.
 */
 
 /*! \class QBitArray::bitarr_data
   \brief The QBitArray::bitarr_data class is internal.
   \internal
 */
 
 
 /*!
     Constructs an empty bit array.
 */
 
 QBitArray::QBitArray() : QByteArray( 0, 0 )
 {
     bitarr_data *x = new bitarr_data;
     Q_CHECK_PTR( x );
     x->nbits = 0;
     setSharedBlock( x );
 }
 
 /*!
     Constructs a bit array of \a size bits. The bits are uninitialized.
 
     \sa fill()
 */
 
 QBitArray::QBitArray( uint size ) : QByteArray( 0, 0 )
 {
     bitarr_data *x = new bitarr_data;
     Q_CHECK_PTR( x );
     x->nbits = 0;
     setSharedBlock( x );
     resize( size );
 }
 
 /*!
     \fn QBitArray::QBitArray( const QBitArray &a )
 
     Constructs a shallow copy of \a a.
 */
 
 /*!
     \fn QBitArray &QBitArray::operator=( const QBitArray &a )
 
     Assigns a shallow copy of \a a to this bit array and returns a
     reference to this array.
 */
 
 
 /*!
     Pad last byte with 0-bits.
 */
 void QBitArray::pad0()
 {
     uint sz = size();
     if ( sz && sz%8 )
 	*(data()+sz/8) &= (1 << (sz%8)) - 1;
 }
 
 
 /*!
     \fn uint QBitArray::size() const
 
     Returns the bit array's size (number of bits).
 
     \sa resize()
 */
 
 /*!
     Resizes the bit array to \a size bits and returns TRUE if the bit
-    array could be resized; otherwise returns FALSE.
+    array could be resized; otherwise returns FALSE. The array becomes
+    a null array if \a size == 0.
 
     If the array is expanded, the new bits are set to 0.
 
     \sa size()
 */
 
 bool QBitArray::resize( uint size )
 {
     uint s = this->size();
     if ( !QByteArray::resize( (size+7)/8 ) )
 	return FALSE;				// cannot resize
     SHBLOCK->nbits = size;
     if ( size != 0 ) {				// not null array
 	int ds = (int)(size+7)/8 - (int)(s+7)/8;// number of bytes difference
 	if ( ds > 0 )				// expanding array
 	    memset( data() + (s+7)/8, 0, ds );	//   reset new data
     }
     return TRUE;
 }
 
 
 /*!
     Fills the bit array with \a v (1's if \a v is TRUE, or 0's if \a v
     is FALSE).
 
     fill() resizes the bit array to \a size bits if \a size is
     nonnegative.
 
     Returns FALSE if a nonnegative \e size was specified and the bit
     array could not be resized; otherwise returns TRUE.
 
     \sa resize()
 */
 
 bool QBitArray::fill( bool v, int size )
 {
     if ( size >= 0 ) {				// resize first
 	if ( !resize( size ) )
 	    return FALSE;			// cannot resize
     } else {
 	size = this->size();
     }
     if ( size > 0 )
 	memset( data(), v ? 0xff : 0, (size + 7) / 8 );
     if ( v )
 	pad0();
     return TRUE;
 }
 
 
 /*!
     Detaches from shared bit array data and makes sure that this bit
     array is the only one referring to the data.
 
     If multiple bit arrays share common data, this bit array
     dereferences the data and gets a copy of the data. Nothing happens
     if there is only a single reference.
 
     \sa copy()
 */
 
 void QBitArray::detach()
 {
     int nbits = SHBLOCK->nbits;
     this->duplicate( *this );
     SHBLOCK->nbits = nbits;
 }
 
 /*!
     Returns a deep copy of the bit array.
 
     \sa detach()
 */
 
 QBitArray QBitArray::copy() const
 {
     QBitArray tmp;
     tmp.duplicate( *this );
     ((bitarr_data*)(tmp.sharedBlock()))->nbits = SHBLOCK->nbits;
     return tmp;
 }
 
 
 /*!
     Returns TRUE if the bit at position \a index is set, i.e. is 1;
     otherwise returns FALSE.
 
     \sa setBit(), clearBit()
 */
 
 bool QBitArray::testBit( uint index ) const
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= size() ) {
 	qWarning( "QBitArray::testBit: Index %d out of range", index );
 	return FALSE;
     }
 #endif
     return (*(data()+(index>>3)) & (1 << (index & 7))) != 0;
 }
 
 /*!
     \overload
 
     Sets the bit at position \a index to 1.
 
     \sa clearBit() toggleBit()
 */
 
 void QBitArray::setBit( uint index )
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= size() ) {
 	qWarning( "QBitArray::setBit: Index %d out of range", index );
 	return;
     }
 #endif
     *(data()+(index>>3)) |= (1 << (index & 7));
 }
 
 /*!
     \fn void QBitArray::setBit( uint index, bool value )
 
     Sets the bit at position \a index to \a value.
 
     Equivalent to:
     \code
     if ( value )
 	setBit( index );
     else
 	clearBit( index );
     \endcode
 
     \sa clearBit() toggleBit()
 */
 
 /*!
     Clears the bit at position \a index, i.e. sets it to 0.
 
     \sa setBit(), toggleBit()
 */
 
 void QBitArray::clearBit( uint index )
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= size() ) {
 	qWarning( "QBitArray::clearBit: Index %d out of range", index );
 	return;
     }
 #endif
     *(data()+(index>>3)) &= ~(1 << (index & 7));
 }
 
 /*!
     Toggles the bit at position \a index.
 
     If the previous value was 0, the new value will be 1. If the
     previous value was 1, the new value will be 0.
 
     \sa setBit(), clearBit()
 */
 
 bool QBitArray::toggleBit( uint index )
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= size() ) {
 	qWarning( "QBitArray::toggleBit: Index %d out of range", index );
 	return FALSE;
     }
 #endif
     register uchar *p = (uchar *)data() + (index>>3);
     uchar b = (1 << (index & 7));		// bit position
     uchar c = *p & b;				// read bit
     *p ^= b;					// toggle bit
     return c;
 }
 
 
 /*!
     \fn bool QBitArray::at( uint index ) const
 
     Returns the value (0 or 1) of the bit at position \a index.
 
     \sa operator[]()
 */
 
 /*!
     \fn QBitVal QBitArray::operator[]( int index )
 
     Implements the [] operator for bit arrays.
 
     The returned QBitVal is a context object. It makes it possible to
     get and set a single bit value by its \a index position.
 
     Example:
     \code
     QBitArray a( 3 );
     a[0] = 0;
     a[1] = 1;
     a[2] = a[0] ^ a[1];
     \endcode
 
     The functions testBit(), setBit() and clearBit() are faster.
 
     \sa at()
 */
 
 /*!
     \overload bool QBitArray::operator[]( int index ) const
 
     Implements the [] operator for constant bit arrays.
 */
 
 
 /*!
     Performs the AND operation between all bits in this bit array and
     \a a. Returns a reference to this bit array.
 
     The result has the length of the longest of the two bit arrays,
     with any missing bits (i.e. if one array is shorter than the
     other), taken to be 0.
     \code
     QBitArray a( 3 ), b( 2 );
     a[0] = 1;  a[1] = 0;  a[2] = 1;     // a = [1 0 1]
     b[0] = 1;  b[1] = 0;                // b = [1 0]
     a &= b;                             // a = [1 0 0]
     \endcode
 
     \sa operator|=(), operator^=(), operator~()
 */
 
 QBitArray &QBitArray::operator&=( const QBitArray &a )
 {
     resize( QMAX(size(), a.size()) );
     register uchar *a1 = (uchar *)data();
     register uchar *a2 = (uchar *)a.data();
     int n = QMIN( QByteArray::size(), a.QByteArray::size() );
     int p = QMAX( QByteArray::size(), a.QByteArray::size() ) - n;
     while ( n-- > 0 )
 	*a1++ &= *a2++;
     while ( p-- > 0 )
 	*a1++ = 0;
     return *this;
 }
 
 /*!
     Performs the OR operation between all bits in this bit array and
     \a a. Returns a reference to this bit array.
 
     The result has the length of the longest of the two bit arrays,
     with any missing bits (i.e. if one array is shorter than the
     other), taken to be 0.
     \code
     QBitArray a( 3 ), b( 2 );
     a[0] = 1;  a[1] = 0;  a[2] = 1;     // a = [1 0 1]
     b[0] = 1;  b[1] = 0;                // b = [1 0]
     a |= b;                             // a = [1 0 1]
     \endcode
 
     \sa operator&=(), operator^=(), operator~()
 */
 
 QBitArray &QBitArray::operator|=( const QBitArray &a )
 {
     resize( QMAX(size(), a.size()) );
     register uchar *a1 = (uchar *)data();
     register uchar *a2 = (uchar *)a.data();
     int n = QMIN( QByteArray::size(), a.QByteArray::size() );
     while ( n-- > 0 )
 	*a1++ |= *a2++;
     return *this;
 }
 
 /*!
     Performs the XOR operation between all bits in this bit array and
     \a a. Returns a reference to this bit array.
 
     The result has the length of the longest of the two bit arrays,
     with any missing bits (i.e. if one array is shorter than the
     other), taken to be 0.
     \code
     QBitArray a( 3 ), b( 2 );
     a[0] = 1;  a[1] = 0;  a[2] = 1;     // a = [1 0 1]
     b[0] = 1;  b[1] = 0;                // b = [1 0]
     a ^= b;                             // a = [0 0 1]
     \endcode
 
     \sa operator&=(), operator|=(), operator~()
 */
 
 QBitArray &QBitArray::operator^=( const QBitArray &a )
 {
     resize( QMAX(size(), a.size()) );
     register uchar *a1 = (uchar *)data();
     register uchar *a2 = (uchar *)a.data();
     int n = QMIN( QByteArray::size(), a.QByteArray::size() );
     while ( n-- > 0 )
 	*a1++ ^= *a2++;
     return *this;
 }
 
 /*!
     Returns a bit array that contains the inverted bits of this bit array.
 
     Example:
     \code
     QBitArray a( 3 ), b;
     a[0] = 1;  a[1] = 0; a[2] = 1;	// a = [1 0 1]
     b = ~a;				// b = [0 1 0]
     \endcode
 */
 
 QBitArray QBitArray::operator~() const
 {
     QBitArray a( size() );
     register uchar *a1 = (uchar *)data();
     register uchar *a2 = (uchar *)a.data();
     int n = QByteArray::size();
     while ( n-- )
 	*a2++ = ~*a1++;
     a.pad0();
     return a;
 }
 
 
 /*!
     \relates QBitArray
 
     Returns the AND result between the bit arrays \a a1 and \a a2.
 
     The result has the length of the longest of the two bit arrays,
     with any missing bits (i.e. if one array is shorter than the
     other), taken to be 0.
 
     \sa QBitArray::operator&=()
 */
 
 QBitArray operator&( const QBitArray &a1, const QBitArray &a2 )
 {
     QBitArray tmp = a1.copy();
     tmp &= a2;
     return tmp;
 }
 
 /*!
     \relates QBitArray
 
     Returns the OR result between the bit arrays \a a1 and \a a2.
 
     The result has the length of the longest of the two bit arrays,
     with any missing bits (i.e. if one array is shorter than the
     other), taken to be 0.
 
     \sa QBitArray::operator|=()
 */
 
 QBitArray operator|( const QBitArray &a1, const QBitArray &a2 )
 {
     QBitArray tmp = a1.copy();
     tmp |= a2;
     return tmp;
 }
 
 /*!
     \relates QBitArray
 
     Returns the XOR result between the bit arrays \a a1 and \a a2.
 
     The result has the length of the longest of the two bit arrays,
     with any missing bits (i.e. if one array is shorter than the
     other), taken to be 0.
 
     \sa QBitArray::operator^()
 */
 
 QBitArray operator^( const QBitArray &a1, const QBitArray &a2 )
 {
     QBitArray tmp = a1.copy();
     tmp ^= a2;
     return tmp;
 }
 
 
 /* \enum QGArray::array_data
 
   \warning This will be renamed in the next major release of Qt.  Until
   then it is undocumented and we recommend against its use.
 
   \internal
 
   ### 3.0 rename ###
   ### 3.0 move it to QGArray? ###
 */
 
 
 /*!
     \fn QBitArray::array_data * QBitArray::newData()
 
     \internal
 
     Returns data specific to QBitArray that extends what QGArray provides.
     QPtrCollection mechanism for allowing extra/different data.
 */
 
 
 /*!
     \fn void  QBitArray::deleteData ( array_data * d )
 
     \internal
 
     Deletes data specific to QBitArray that extended what QGArray provided.
 
     QPtrCollection mechanism for allowing extra/different data.
 */
 
 
 /*****************************************************************************
   QBitArray stream functions
  *****************************************************************************/
 
 /*!
     \relates QBitArray
 
     Writes bit array \a a to stream \a s.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 #ifndef QT_NO_DATASTREAM
 QDataStream &operator<<( QDataStream &s, const QBitArray &a )
 {
     Q_UINT32 len = a.size();
     s << len;					// write size of array
     if ( len > 0 )				// write data
 	s.writeRawBytes( a.data(), a.QByteArray::size() );
     return s;
 }
 
 /*!
     \relates QBitArray
 
     Reads a bit array into \a a from stream \a s.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator>>( QDataStream &s, QBitArray &a )
 {
     Q_UINT32 len;
     s >> len;					// read size of array
     if ( !a.resize( (uint)len ) ) {		// resize array
 #if defined(QT_CHECK_NULL)
 	qWarning( "QDataStream: Not enough memory to read QBitArray" );
 #endif
 	len = 0;
     }
     if ( len > 0 )				// read data
 	s.readRawBytes( a.data(), a.QByteArray::size() );
     return s;
 }
 
 #endif // QT_NO_DATASTREAM
diff --git a/qmake/tools/qbuffer.cpp b/qmake/tools/qbuffer.cpp
index b213dd9..0fc90e4 100644
--- a/qmake/tools/qbuffer.cpp
+++ b/qmake/tools/qbuffer.cpp
@@ -1,495 +1,495 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QBuffer class
 **
 ** Created : 930812
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qbuffer.h"
 #include <stdlib.h>
 
 /*!
     \class QBuffer qbuffer.h
     \reentrant
     \brief The QBuffer class is an I/O device that operates on a QByteArray.
 
     \ingroup io
     \ingroup collection
 
     QBuffer is used to read and write to a memory buffer. It is
     normally used with a QTextStream or a QDataStream. QBuffer has an
     associated QByteArray which holds the buffer data. The size() of
     the buffer is automatically adjusted as data is written.
 
     The constructor \c QBuffer(QByteArray) creates a QBuffer using an
     existing byte array. The byte array can also be set with
     setBuffer(). Writing to the QBuffer will modify the original byte
     array because QByteArray is \link shclass.html explicitly
     shared.\endlink
 
     Use open() to open the buffer before use and to set the mode
     (read-only, write-only, etc.). close() closes the buffer. The
     buffer must be closed before reopening or calling setBuffer().
 
     A common way to use QBuffer is through \l QDataStream or \l
     QTextStream, which have constructors that take a QBuffer
     parameter. For convenience, there are also QDataStream and
     QTextStream constructors that take a QByteArray parameter. These
     constructors create and open an internal QBuffer.
 
     Note that QTextStream can also operate on a QString (a Unicode
     string); a QBuffer cannot.
 
     You can also use QBuffer directly through the standard QIODevice
     functions readBlock(), writeBlock() readLine(), at(), getch(),
     putch() and ungetch().
 
     \sa QFile, QDataStream, QTextStream, QByteArray, \link shclass.html Shared Classes\endlink
 */
 
 
 /*!
     Constructs an empty buffer.
 */
 
 QBuffer::QBuffer()
 {
     setFlags( IO_Direct );
     a_inc = 16;                                 // initial increment
     a_len = 0;
     ioIndex = 0;
 }
 
 
 /*!
     Constructs a buffer that operates on \a buf.
 
     If you open the buffer in write mode (\c IO_WriteOnly or
     \c IO_ReadWrite) and write something into the buffer, \a buf
     will be modified.
 
     Example:
     \code
     QCString str = "abc";
     QBuffer b( str );
     b.open( IO_WriteOnly );
     b.at( 3 ); // position at the 4th character (the terminating \0)
     b.writeBlock( "def", 4 ); // write "def" including the terminating \0
     b.close();
     // Now, str == "abcdef" with a terminating \0
     \endcode
 
     \sa setBuffer()
 */
 
 QBuffer::QBuffer( QByteArray buf ) : a(buf)
 {
     setFlags( IO_Direct );
     a_len = a.size();
     a_inc = (a_len > 512) ? 512 : a_len;        // initial increment
     if ( a_inc < 16 )
         a_inc = 16;
     ioIndex = 0;
 }
 
 /*!
     Destroys the buffer.
 */
 
 QBuffer::~QBuffer()
 {
 }
 
 
 /*!
     Replaces the buffer's contents with \a buf and returns TRUE.
 
     Does nothing (and returns FALSE) if isOpen() is TRUE.
 
     Note that if you open the buffer in write mode (\c IO_WriteOnly or
     IO_ReadWrite) and write something into the buffer, \a buf is also
     modified because QByteArray is an explicitly shared class.
 
     \sa buffer(), open(), close()
 */
 
 bool QBuffer::setBuffer( QByteArray buf )
 {
     if ( isOpen() ) {
 #if defined(QT_CHECK_STATE)
         qWarning( "QBuffer::setBuffer: Buffer is open" );
 #endif
         return FALSE;
     }
     a = buf;
     a_len = a.size();
     a_inc = (a_len > 512) ? 512 : a_len;        // initial increment
     if ( a_inc < 16 )
         a_inc = 16;
     ioIndex = 0;
     return TRUE;
 }
 
 /*!
     \fn QByteArray QBuffer::buffer() const
 
     Returns this buffer's byte array.
 
     \sa setBuffer()
 */
 
 /*!
     \reimp
 
     Opens the buffer in mode \a m. Returns TRUE if successful;
     otherwise returns FALSE. The buffer must be opened before use.
 
     The mode parameter \a m must be a combination of the following flags.
     \list
     \i \c IO_ReadOnly opens the buffer in read-only mode.
     \i \c IO_WriteOnly opens the buffer in write-only mode.
     \i \c IO_ReadWrite opens the buffer in read/write mode.
     \i \c IO_Append sets the buffer index to the end of the buffer.
     \i \c IO_Truncate truncates the buffer.
     \endlist
 
     \sa close(), isOpen()
 */
 
 bool QBuffer::open( int m  )
 {
     if ( isOpen() ) {                           // buffer already open
 #if defined(QT_CHECK_STATE)
         qWarning( "QBuffer::open: Buffer already open" );
 #endif
         return FALSE;
     }
     setMode( m );
     if ( m & IO_Truncate ) {                    // truncate buffer
-        a.resize( 0 );
-        a_len = 0;
+        a.resize( 1 );
+        a_len = 1;
     }
     if ( m & IO_Append ) {                      // append to end of buffer
         ioIndex = a.size();
     } else {
         ioIndex = 0;
     }
     a_inc = 16;
     setState( IO_Open );
     setStatus( 0 );
     return TRUE;
 }
 
 /*!
     \reimp
 
     Closes an open buffer.
 
     \sa open()
 */
 
 void QBuffer::close()
 {
     if ( isOpen() ) {
         setFlags( IO_Direct );
         ioIndex = 0;
         a_inc = 16;
     }
 }
 
 /*!
     \reimp
 
     The flush function does nothing for a QBuffer.
 */
 
 void QBuffer::flush()
 {
     return;
 }
 
 
 /*!
     \fn QIODevice::Offset QBuffer::at() const
 
     \reimp
 */
 
 /*!
     \fn QIODevice::Offset QBuffer::size() const
 
     \reimp
 */
 
 /*!
   \reimp
 */
 
 bool QBuffer::at( Offset pos )
 {
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {
         qWarning( "QBuffer::at: Buffer is not open" );
         return FALSE;
     }
 #endif
     if ( pos > a_len ) {
 #if defined(QT_CHECK_RANGE)
 #if defined(QT_LARGEFILE_SUPPORT) && defined(QT_ABI_64BITOFFSET)
         qWarning( "QBuffer::at: Index %llu out of range", pos );
 #else
         qWarning( "QBuffer::at: Index %lu out of range", pos );
 #endif
 #endif
         return FALSE;
     }
     ioIndex = pos;
     return TRUE;
 }
 
 
 /*!
   \reimp
 */
 
 Q_LONG QBuffer::readBlock( char *p, Q_ULONG len )
 {
 #if defined(QT_CHECK_STATE)
     if ( !p ) {
 	qWarning( "QBuffer::readBlock: Null pointer error" );
 	return -1;
     }
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::readBlock: Buffer not open" );
         return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
         qWarning( "QBuffer::readBlock: Read operation not permitted" );
         return -1;
     }
 #endif
     if ( ioIndex + len > a.size() ) {   // overflow
         if ( ioIndex >= a.size() ) {
             return 0;
         } else {
             len = a.size() - ioIndex;
         }
     }
     memcpy( p, a.data()+ioIndex, len );
     ioIndex += len;
     return len;
 }
 
 /*!
     \overload Q_LONG QBuffer::writeBlock( const QByteArray& data )
 
     This convenience function is the same as calling
     \c{writeBlock( data.data(), data.size() )} with \a data.
 */
 
 /*!
     Writes \a len bytes from \a p into the buffer at the current
     index position, overwriting any characters there and extending the
     buffer if necessary. Returns the number of bytes actually written.
 
     Returns -1 if an error occurred.
 
     \sa readBlock()
 */
 
 Q_LONG QBuffer::writeBlock( const char *p, Q_ULONG len )
 {
     if ( len == 0 )
         return 0;
 
 #if defined(QT_CHECK_NULL)
     if ( p == 0 ) {
         qWarning( "QBuffer::writeBlock: Null pointer error" );
         return -1;
     }
 #endif
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::writeBlock: Buffer not open" );
         return -1;
     }
     if ( !isWritable() ) {                      // writing not permitted
         qWarning( "QBuffer::writeBlock: Write operation not permitted" );
         return -1;
     }
 #endif
     if ( ioIndex + len >= a_len ) {             // overflow
         Q_ULONG new_len = a_len + a_inc*((ioIndex+len-a_len)/a_inc+1);
         if ( !a.resize( new_len ) ) {           // could not resize
 #if defined(QT_CHECK_NULL)
             qWarning( "QBuffer::writeBlock: Memory allocation error" );
 #endif
             setStatus( IO_ResourceError );
             return -1;
         }
         a_inc *= 2;                             // double increment
         a_len = new_len;
         a.shd->len = ioIndex + len;
     }
     memcpy( a.data()+ioIndex, p, len );
     ioIndex += len;
     if ( a.shd->len < ioIndex )
         a.shd->len = ioIndex;                   // fake (not alloc'd) length
     return len;
 }
 
 
 /*!
   \reimp
 */
 
 Q_LONG QBuffer::readLine( char *p, Q_ULONG maxlen )
 {
 #if defined(QT_CHECK_NULL)
     if ( p == 0 ) {
         qWarning( "QBuffer::readLine: Null pointer error" );
         return -1;
     }
 #endif
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::readLine: Buffer not open" );
         return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
         qWarning( "QBuffer::readLine: Read operation not permitted" );
         return -1;
     }
 #endif
     if ( maxlen == 0 )
         return 0;
     Q_ULONG start = ioIndex;
     char *d = a.data() + ioIndex;
     maxlen--;                                   // make room for 0-terminator
     if ( a.size() - ioIndex < maxlen )
         maxlen = a.size() - ioIndex;
     while ( maxlen-- ) {
         if ( (*p++ = *d++) == '\n' )
             break;
     }
     *p = '\0';
     ioIndex = d - a.data();
     return ioIndex - start;
 }
 
 
 /*!
   \reimp
 */
 
 int QBuffer::getch()
 {
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::getch: Buffer not open" );
         return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
         qWarning( "QBuffer::getch: Read operation not permitted" );
         return -1;
     }
 #endif
     if ( ioIndex+1 > a.size() ) {               // overflow
         setStatus( IO_ReadError );
         return -1;
     }
     return uchar(*(a.data()+ioIndex++));
 }
 
 /*!
     \reimp
 
     Writes the character \a ch into the buffer at the current index
     position, overwriting any existing character and extending the
     buffer if necessary.
 
     Returns \a ch, or -1 if an error occurred.
 
     \sa getch(), ungetch()
 */
 
 int QBuffer::putch( int ch )
 {
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::putch: Buffer not open" );
         return -1;
     }
     if ( !isWritable() ) {                      // writing not permitted
         qWarning( "QBuffer::putch: Write operation not permitted" );
         return -1;
     }
 #endif
     if ( ioIndex + 1 >= a_len ) {               // overflow
         char buf[1];
         buf[0] = (char)ch;
         if ( writeBlock(buf,1) != 1 )
             return -1;                          // write error
     } else {
         *(a.data() + ioIndex++) = (char)ch;
         if ( a.shd->len < ioIndex )
             a.shd->len = ioIndex;
     }
     return ch;
 }
 
 /*!
   \reimp
 */
 
 int QBuffer::ungetch( int ch )
 {
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::ungetch: Buffer not open" );
         return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
         qWarning( "QBuffer::ungetch: Read operation not permitted" );
         return -1;
     }
 #endif
     if ( ch != -1 ) {
         if ( ioIndex )
             ioIndex--;
         else
             ch = -1;
     }
     return ch;
 }
 
diff --git a/qmake/tools/qcomlibrary.cpp b/qmake/tools/qcomlibrary.cpp
index a7162fc..2a1b75a 100644
--- a/qmake/tools/qcomlibrary.cpp
+++ b/qmake/tools/qcomlibrary.cpp
@@ -1,538 +1,535 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QComLibrary class
 **
 ** Copyright (C) 2001-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qcomlibrary_p.h"
 
 #ifndef QT_NO_COMPONENT
 #include <qapplication.h>
 #include <qsettings.h>
 #include <qfileinfo.h>
 #include <qdatetime.h>
 #include <qcleanuphandler.h>
 #include <errno.h>
 
 #ifdef QT_THREAD_SUPPORT
 #  include "qmutexpool_p.h"
 #endif // QT_THREAD_SUPPORT
 
 #ifndef QT_DEBUG_COMPONENT
 # if defined(QT_DEBUG)
 #  define QT_DEBUG_COMPONENT 1
 # endif
 #endif
 
 
 QComLibrary::QComLibrary( const QString &filename )
     : QLibrary( filename ), entry( 0 ), libiface( 0 ), qt_version( 0 )
 {
 }
 
 QComLibrary::~QComLibrary()
 {
     if ( autoUnload() )
 	unload();
+    if ( libiface )
+	libiface->release();
+    if ( entry )
+	entry->release();
 }
 
 bool QComLibrary::unload()
 {
     if ( libiface ) {
 	libiface->cleanup();
 	if ( !libiface->canUnload() )
 	    return FALSE;
 	libiface->release();
 	libiface = 0;
     }
     int refs = entry ? entry->release() : 0;
     if ( refs )
 	return FALSE;
 
     entry = 0;
 
     return QLibrary::unload();
 }
 
 static bool qt_verify( const QString& library, uint version, uint flags,
 		    const QCString &key, bool warn )
 {
     uint our_flags = 1;
 #if defined(QT_THREAD_SUPPORT)
     our_flags |= 2;
 #endif
 
     if ( (flags & 1) == 0 ) {
 	if ( warn )
 	    qWarning( "Conflict in %s:\n"
 		      "  Plugin cannot be queried successfully!",
 		      (const char*) QFile::encodeName(library) );
     } else if ( ( version > QT_VERSION ) ||
 		( ( QT_VERSION & 0xff0000 ) > ( version & 0xff0000 ) ) ) {
 	if ( warn )
 	    qWarning( "Conflict in %s:\n"
 		      "  Plugin uses incompatible Qt library (%d.%d.%d)!",
 		      (const char*) QFile::encodeName(library),
 		      (version&0xff0000) >> 16, (version&0xff00) >> 8, version&0xff );
     } else if ( (flags & 2) != (our_flags & 2) ) {
 	if ( warn )
 	    qWarning( "Conflict in %s:\n"
 		      "  Plugin uses %s Qt library!",
 		      (const char*) QFile::encodeName(library),
 		      (flags & 2) ? "multi threaded" : "single threaded" );
     } else if ( key != QT_BUILD_KEY ) {
 	if ( warn )
 	    qWarning( "Conflict in %s:\n"
 		      "  Plugin uses incompatible Qt library!\n"
 		      "  expected build key \"%s\", got \"%s\".",
 		      (const char*) QFile::encodeName(library),
 		      QT_BUILD_KEY,
 		      key.isEmpty() ? "<null>" : (const char *) key );
     } else {
 	return TRUE;
     }
     return FALSE;
 }
 
 struct qt_token_info
 {
     qt_token_info( const char *f, const ulong fc )
 	: fields( f ), field_count( fc ), results( fc ), lengths( fc )
     {
 	results.fill( 0 );
 	lengths.fill( 0 );
     }
 
     const char *fields;
     const ulong field_count;
 
     QMemArray<const char *> results;
     QMemArray<ulong> lengths;
 };
 
 /*
   return values:
        1 parse ok
        0 eos
       -1 parse error
 */
 static int qt_tokenize( const char *s, ulong s_len, ulong *advance,
 			const qt_token_info &token_info )
 {
     ulong pos = 0, field = 0, fieldlen = 0;
     char current;
     int ret = -1;
     *advance = 0;
     for (;;) {
 	current = s[ pos ];
 
 	// next char
 	++pos;
 	++fieldlen;
 	++*advance;
 
 	if ( ! current || pos == s_len + 1 ) {
 	    // save result
 	    token_info.results[ (int)field ] = s;
 	    token_info.lengths[ (int)field ] = fieldlen - 1;
 
 	    // end of string
 	    ret = 0;
 	    break;
 	}
 
 	if ( current == token_info.fields[ field ] ) {
 	    // save result
 	    token_info.results[ (int)field ] = s;
 	    token_info.lengths[ (int)field ] = fieldlen - 1;
 
 	    // end of field
 	    fieldlen = 0;
 	    ++field;
 	    if ( field == token_info.field_count - 1 ) {
 		// parse ok
 		ret = 1;
 	    }
 	    if ( field == token_info.field_count ) {
 		// done parsing
 		break;
 	    }
 
 	    // reset string and its length
 	    s = s + pos;
 	    s_len -= pos;
 	    pos = 0;
 	}
     }
 
     return ret;
 }
 
 /*
   returns TRUE if the string s was correctly parsed, FALSE otherwise.
 */
 static bool qt_parse_pattern( const char *s, uint *version, uint *flags,
 				   QCString *key )
 {
     bool ret = TRUE;
 
     qt_token_info pinfo("=\n", 2);
     int parse;
     ulong at = 0, advance, parselen = qstrlen( s );
     do {
 	parse = qt_tokenize( s + at, parselen, &advance, pinfo );
 	if ( parse == -1 ) {
 	    ret = FALSE;
 	    break;
 	}
 
 	at += advance;
 	parselen -= advance;
 
 	if ( qstrncmp( "version", pinfo.results[ 0 ], pinfo.lengths[ 0 ] ) == 0 ) {
 	    // parse version string
 	    qt_token_info pinfo2("..-", 3);
 	    if ( qt_tokenize( pinfo.results[ 1 ], pinfo.lengths[ 1 ],
 			      &advance, pinfo2 ) != -1 ) {
 		QCString m( pinfo2.results[ 0 ], pinfo2.lengths[ 0 ] + 1 );
 		QCString n( pinfo2.results[ 1 ], pinfo2.lengths[ 1 ] + 1 );
 		QCString p( pinfo2.results[ 2 ], pinfo2.lengths[ 2 ] + 1 );
 		*version  = (m.toUInt() << 16) | (n.toUInt() << 8) | p.toUInt();
 	    } else {
 		ret = FALSE;
 		break;
 	    }
 	} else if ( qstrncmp( "flags", pinfo.results[ 0 ], pinfo.lengths[ 0 ] ) == 0 ) {
 	    // parse flags string
 	    char ch;
 	    *flags = 0;
 	    ulong p = 0, c = 0, bit = 0;
 	    while ( p < pinfo.lengths[ 1 ] ) {
 		ch = pinfo.results[ 1 ][ p ];
 		bit = pinfo.lengths[ 1 ] - p - 1;
 		c = 1 << bit;
 		if ( ch == '1' ) {
 		    *flags |= c;
 		} else if ( ch != '0' ) {
 		    ret = FALSE;
 		    break;
 		}
 		++p;
 	    }
 	} else if ( qstrncmp( "buildkey", pinfo.results[ 0 ],
 			      pinfo.lengths[ 0 ] ) == 0 ){
 	    // save buildkey
 	    *key = QCString( pinfo.results[ 1 ], pinfo.lengths[ 1 ] + 1 );
 	}
     } while ( parse == 1 && parselen > 0 );
 
     return ret;
 }
 
 #if defined(Q_OS_UNIX)
 
 #if defined(Q_OS_FREEBSD) || defined(Q_OS_LINUX)
 #  define USE_MMAP
 #  include <sys/types.h>
 #  include <sys/mman.h>
 #endif // Q_OS_FREEBSD || Q_OS_LINUX
 
 static long qt_find_pattern( const char *s, ulong s_len,
 			     const char *pattern, ulong p_len )
 {
     /*
       this uses the same algorithm as QString::findRev...
 
       we search from the end of the file because on the supported
       systems, the read-only data/text segments are placed at the end
       of the file.  HOWEVER, when building with debugging enabled, all
       the debug symbols are placed AFTER the data/text segments.
 
       what does this mean?  when building in release mode, the search
       is fast because the data we are looking for is at the end of the
       file... when building in debug mode, the search is slower
       because we have to skip over all the debugging symbols first
     */
 
     if ( ! s || ! pattern || p_len > s_len ) return -1;
     ulong i, hs = 0, hp = 0, delta = s_len - p_len;
 
     for (i = 0; i < p_len; ++i ) {
 	hs += s[delta + i];
 	hp += pattern[i];
     }
     i = delta;
     for (;;) {
 	if ( hs == hp && qstrncmp( s + i, pattern, p_len ) == 0 )
 	    return i;
 	if ( i == 0 )
 	    break;
 	--i;
 	hs -= s[i + p_len];
 	hs += s[i];
     }
 
     return -1;
 }
 
 /*
   This opens the specified library, mmaps it into memory, and searches
   for the QT_UCM_VERIFICATION_DATA.  The advantage of this approach is that
   we can get the verification data without have to actually load the library.
   This lets us detect mismatches more safely.
 
   Returns FALSE if version/flags/key information is not present, or if the
                 information could not be read.
   Returns  TRUE if version/flags/key information is present and succesfully read.
 */
 static bool qt_unix_query( const QString &library, uint *version, uint *flags,
 			   QCString *key )
 {
     QFile file( library );
     if (! file.open( IO_ReadOnly ) ) {
 	qWarning( "%s: %s", (const char*) QFile::encodeName(library),
 	    strerror( errno ) );
 	return FALSE;
     }
 
     QByteArray data;
     char *filedata = 0;
     ulong fdlen = 0;
 
 #ifdef USE_MMAP
     char *mapaddr = 0;
     size_t maplen = file.size();
     mapaddr = (char *) mmap( mapaddr, maplen, PROT_READ, MAP_PRIVATE, file.handle(), 0 );
     if ( mapaddr != MAP_FAILED ) {
 	// mmap succeeded
 	filedata = mapaddr;
 	fdlen = maplen;
     } else {
 	// mmap failed
 	qWarning( "mmap: %s", strerror( errno ) );
 #endif // USE_MMAP
 	// try reading the data into memory instead
 	data = file.readAll();
 	filedata = data.data();
 	fdlen = data.size();
 #ifdef USE_MMAP
     }
 #endif // USE_MMAP
 
     // verify that the pattern is present in the plugin
     const char *pattern = "pattern=QT_UCM_VERIFICATION_DATA";
     const ulong plen = qstrlen( pattern );
     long pos = qt_find_pattern( filedata, fdlen, pattern, plen );
 
     bool ret = FALSE;
     if ( pos >= 0 ) {
 	ret = qt_parse_pattern( filedata + pos, version, flags, key );
     }
 
 #ifdef USE_MMAP
     if ( mapaddr != MAP_FAILED && munmap(mapaddr, maplen) != 0 ) {
 	qWarning( "munmap: %s", strerror( errno ) );
     }
 #endif // USE_MMAP
 
     file.close();
     return ret;
 }
 
 #endif // Q_OS_UNIX
 
 
 static QSettings *cache = 0;
 static QSingleCleanupHandler<QSettings> cleanup_cache;
 
 void QComLibrary::createInstanceInternal()
 {
     if ( library().isEmpty() )
 	return;
 
     QFileInfo fileinfo( library() );
     QString lastModified  = fileinfo.lastModified().toString();
     QString regkey = QString("/Qt Plugins %1.%2/%3")
 		     .arg( ( QT_VERSION & 0xff0000 ) >> 16 )
 		     .arg( ( QT_VERSION & 0xff00 ) >> 8 )
 		     .arg( library() );
     QStringList reg;
     uint flags = 0;
     QCString key;
     bool query_done = FALSE;
     bool warn_mismatch = TRUE;
 
-    if ( ! query_done ) {
-
 #ifdef QT_THREAD_SUPPORT
-	QMutexLocker locker( qt_global_mutexpool->get( &cache ) );
+    QMutexLocker locker( qt_global_mutexpool ?
+			 qt_global_mutexpool->get( &cache ) : 0 );
 #endif // QT_THREAD_SUPPORT
 
-	if ( ! cache ) {
-	    cache = new QSettings;
-	    cache->insertSearchPath( QSettings::Windows, "/Trolltech" );
-	    cleanup_cache.set( &cache );
-	}
+    if ( ! cache ) {
+	cache = new QSettings;
+	cache->insertSearchPath( QSettings::Windows, "/Trolltech" );
+	cleanup_cache.set( &cache );
+    }
 
-	reg = cache->readListEntry( regkey );
-	if ( reg.count() == 4 ) {
-	    // check timestamp
-	    if ( lastModified == reg[3] ) {
-		qt_version = reg[0].toUInt(0, 16);
-		flags = reg[1].toUInt(0, 16);
-		key = reg[2].latin1();
+    reg = cache->readListEntry( regkey );
+    if ( reg.count() == 4 ) {
+	// check timestamp
+	if ( lastModified == reg[3] ) {
+	    qt_version = reg[0].toUInt(0, 16);
+	    flags = reg[1].toUInt(0, 16);
+	    key = reg[2].latin1();
 
-		query_done = TRUE;
-		warn_mismatch = FALSE;
-	    }
+	    query_done = TRUE;
+	    warn_mismatch = FALSE;
 	}
     }
 
 #if defined(Q_OS_UNIX)
     if ( ! query_done ) {
 	// get the query information directly from the plugin without loading
 	if ( qt_unix_query( library(), &qt_version, &flags, &key ) ) {
  	    // info read succesfully from library
  	    query_done = TRUE;
 	}
     }
 #else // !Q_OS_UNIX
     if ( ! query_done ) {
 	// get the query information by loading the plugin
 	if ( !isLoaded() ) {
 	    Q_ASSERT( entry == 0 );
 	    if ( !load() )
 		return;
 	}
 
 #  ifdef Q_CC_BOR
 	typedef const char * __stdcall (*UCMQueryVerificationDataProc)();
 #  else
 	typedef const char * (*UCMQueryVerificationDataProc)();
 #  endif
 	UCMQueryVerificationDataProc ucmQueryVerificationdataProc;
 	ucmQueryVerificationdataProc =
 	    (UCMQueryVerificationDataProc) resolve( "qt_ucm_query_verification_data" );
 
 	if ( !ucmQueryVerificationdataProc ||
 	     !qt_parse_pattern( ucmQueryVerificationdataProc(),
 				&qt_version, &flags, &key ) ) {
 	    qt_version = flags = 0;
 	    key = "unknown";
 	} else {
 	    query_done = TRUE;
 	}
     }
 #endif // Q_OS_UNIX
 
     QStringList queried;
     queried << QString::number( qt_version,16 )
 	    << QString::number( flags, 16 )
 	    <<  key
 	    << lastModified;
 
     if ( queried != reg ) {
-
-#ifdef QT_THREAD_SUPPORT
-	QMutexLocker locker( qt_global_mutexpool->get( &cache ) );
-#endif // QT_THREAD_SUPPORT
-
 	cache->writeEntry( regkey, queried );
 	// delete the cache, which forces the settings to be written
 	delete cache;
 	cache = 0;
     }
 
     if ( ! query_done ) {
 	if ( warn_mismatch ) {
 	    qWarning( "Conflict in %s:\n Plugin cannot be queried successfully!",
 		      (const char*) QFile::encodeName( library() ) );
 	}
 	unload();
 	return;
     }
 
     if ( ! qt_verify( library(), qt_version, flags, key, warn_mismatch ) ) {
 	unload();
 	return;
     } else if ( !isLoaded() ) {
 	Q_ASSERT( entry == 0 );
 	if ( !load() )
 	    return;
     }
 
 #ifdef Q_CC_BOR
     typedef QUnknownInterface* __stdcall (*UCMInstanceProc)();
 #else
     typedef QUnknownInterface* (*UCMInstanceProc)();
 #endif
     UCMInstanceProc ucmInstanceProc;
     ucmInstanceProc = (UCMInstanceProc) resolve( "ucm_instantiate" );
 #if defined(QT_DEBUG_COMPONENT)
     if ( !ucmInstanceProc )
 	qWarning( "%s: Not a UCOM library.", (const char*) QFile::encodeName(library()) );
 #endif
     entry = ucmInstanceProc ? ucmInstanceProc() : 0;
 
     if ( entry ) {
 	if ( entry->queryInterface( IID_QLibrary, (QUnknownInterface**)&libiface ) == QS_OK ) {
 	    if ( libiface && !libiface->init() ) {
 		libiface->release();
 		libiface = 0;
 		unload();
 		return;
 	    }
 	}
     } else {
 #if defined(QT_DEBUG_COMPONENT)
 	qWarning( "%s: No exported component provided.", (const char*) QFile::encodeName(library()) );
 #endif
 	unload();
     }
 }
 
 QRESULT QComLibrary::queryInterface( const QUuid& request, QUnknownInterface** iface )
 {
     if ( !entry )
 	createInstanceInternal();
     return entry ? entry->queryInterface( request, iface ) : QE_NOCOMPONENT;
 }
 
 uint QComLibrary::qtVersion()
 {
     if ( !entry )
 	createInstanceInternal();
     return entry ? qt_version : 0;
 }
 
 
 #endif // QT_NO_COMPONENT
diff --git a/qmake/tools/qconfig.cpp b/qmake/tools/qconfig.cpp
index 433827c..5297a4e 100644
--- a/qmake/tools/qconfig.cpp
+++ b/qmake/tools/qconfig.cpp
@@ -1,17 +1,17 @@
 /* Install paths from configure */
 
-static const char QT_INSTALL_PREFIX [256] = "/usr/src/coding/projects/userspace/qt-embedded-free-3.1.0-b2";
-static const char QT_INSTALL_BINS   [256] = "/usr/src/coding/projects/userspace/qt-embedded-free-3.1.0-b2/bin";
-static const char QT_INSTALL_DOCS   [256] = "/usr/src/coding/projects/userspace/qt-embedded-free-3.1.0-b2/doc";
-static const char QT_INSTALL_HEADERS[256] = "/usr/src/coding/projects/userspace/qt-embedded-free-3.1.0-b2/include";
-static const char QT_INSTALL_LIBS   [256] = "/usr/src/coding/projects/userspace/qt-embedded-free-3.1.0-b2/lib";
-static const char QT_INSTALL_PLUGINS[256] = "/usr/src/coding/projects/userspace/qt-embedded-free-3.1.0-b2/plugins";
-static const char QT_INSTALL_DATA   [256] = "/usr/src/coding/projects/userspace/qt-embedded-free-3.1.0-b2";
+static const char QT_INSTALL_PREFIX [256] = "/opt/qt-x11-free-3.1.2";
+static const char QT_INSTALL_BINS   [256] = "/opt/qt-x11-free-3.1.2/bin";
+static const char QT_INSTALL_DOCS   [256] = "/opt/qt-x11-free-3.1.2/doc";
+static const char QT_INSTALL_HEADERS[256] = "/opt/qt-x11-free-3.1.2/include";
+static const char QT_INSTALL_LIBS   [256] = "/opt/qt-x11-free-3.1.2/lib";
+static const char QT_INSTALL_PLUGINS[256] = "/opt/qt-x11-free-3.1.2/plugins";
+static const char QT_INSTALL_DATA   [256] = "/opt/qt-x11-free-3.1.2";
 
 const char *qInstallPath()        { return QT_INSTALL_PREFIX;  }
 const char *qInstallPathDocs()    { return QT_INSTALL_DOCS;    }
 const char *qInstallPathHeaders() { return QT_INSTALL_HEADERS; }
 const char *qInstallPathLibs()    { return QT_INSTALL_LIBS;    }
 const char *qInstallPathBins()    { return QT_INSTALL_BINS;    }
 const char *qInstallPathPlugins() { return QT_INSTALL_PLUGINS; }
 const char *qInstallPathData()    { return QT_INSTALL_DATA;    }
diff --git a/qmake/tools/qcriticalsection_p.cpp b/qmake/tools/qcriticalsection_p.cpp
index 60fc8bd..c375730 100644
--- a/qmake/tools/qcriticalsection_p.cpp
+++ b/qmake/tools/qcriticalsection_p.cpp
@@ -1,75 +1,73 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QCriticalSection class
 **
-** Created : 
-**
 ** Copyright (C) 2001 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #if defined(QT_THREAD_SUPPORT)
 
 #include "qt_windows.h"
 
 #include <private/qcriticalsection_p.h>
 
 class QCriticalSectionPrivate 
 {
 public:
     QCriticalSectionPrivate() {}
 
     CRITICAL_SECTION section;
 };
 
 
 QCriticalSection::QCriticalSection()
 {
     d = new QCriticalSectionPrivate;
     InitializeCriticalSection( &d->section );
 }
 
 QCriticalSection::~QCriticalSection()
 {
     DeleteCriticalSection( &d->section );
     delete d;
 }
 
 void QCriticalSection::enter()
 {
     EnterCriticalSection( &d->section );
 }
 
 void QCriticalSection::leave()
 {
     LeaveCriticalSection( &d->section );
 }
 
 #endif
diff --git a/qmake/tools/qcstring.cpp b/qmake/tools/qcstring.cpp
index cf1b853..4651b97 100644
--- a/qmake/tools/qcstring.cpp
+++ b/qmake/tools/qcstring.cpp
@@ -1,2474 +1,2511 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of extended char array operations, and QByteArray and
 ** QCString classes
 **
 ** Created : 920722
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qstring.h"
 #include "qregexp.h"
 #include "qdatastream.h"
 
 #ifdef QT_THREAD_SUPPORT
 #  include <private/qmutexpool_p.h>
 #endif // QT_THREAD_SUPPORT
 
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <limits.h>
 #ifndef QT_NO_COMPRESS
 #include "../3rdparty/zlib/zlib.h"
 #endif
 
 /*****************************************************************************
   Safe and portable C string functions; extensions to standard string.h
  *****************************************************************************/
 
 /*!
     \relates QCString
 
     This function is normally part of the C library. Qt implements
     memmove() for platforms that do not provide it.
 
     memmove() copies \a len bytes from \a src into \a dst. The data
     is copied correctly even if \a src and \a dst overlap.
 */
 
 void *qmemmove( void *dst, const void *src, uint len )
 {
     register char *d;
     register char *s;
     if ( dst > src ) {
 	d = (char *)dst + len - 1;
 	s = (char *)src + len - 1;
 	while ( len-- )
 	    *d-- = *s--;
     } else if ( dst < src ) {
 	d = (char *)dst;
 	s = (char *)src;
 	while ( len-- )
 	    *d++ = *s++;
     }
     return dst;
 }
 
 
 /*!
     \relates QCString
 
     Returns a duplicate string.
 
     Allocates space for a copy of \a src, copies it, and returns a
     pointer to the copy. If \a src is 0, it immediately returns 0.
 
     The returned string must be deleted using \c delete[].
 */
 
 char *qstrdup( const char *src )
 {
     if ( !src )
 	return 0;
     char *dst = new char[strlen(src)+1];
     Q_CHECK_PTR( dst );
     return strcpy( dst, src );
 }
 
 /*!
     \fn char *qstrcpy( char *dst, const char *src )
 
     \relates QCString
 
     A safe strcpy() function.
 
     Copies all characters up to and including the '\0' from \a src
     into \a dst and returns a pointer to \a dst.
 */
 
 /*!
     \relates QCString
 
     A safe strncpy() function.
 
     Copies at most \a len bytes from \a src (stopping at \a len or the
     terminating '\0' whichever comes first) into \a dst and returns a
     pointer to \a dst. Guarantees that \a dst is '\0'-terminated. If
     \a src or \a dst is 0, returns 0 immediately.
 
     \sa qstrcpy()
 */
 
 char *qstrncpy( char *dst, const char *src, uint len )
 {
     if ( !src || !dst )
 	return 0;
     strncpy( dst, src, len );
     if ( len > 0 )
 	dst[len-1] = '\0';
     return dst;
 }
 
 /*!
+    \fn uint qstrlen( const char *str );
+
+    \relates QCString
+
+    A safe strlen function.
+
+    Returns the number of characters that precede the terminating '\0'.
+    or 0 if \a str is 0.
+*/
+
+/*!
     \fn int qstrcmp( const char *str1, const char *str2 );
 
     \relates QCString
 
     A safe strcmp() function.
 
     Compares \a str1 and \a str2. Returns a negative value if \a str1
     is less than \a str2, 0 if \a str1 is equal to \a str2 or a
     positive value if \a str1 is greater than \a str2.
 
     Special case I: Returns 0 if \a str1 and \a str2 are both 0.
 
     Special case II: Returns a random nonzero value if \a str1 is 0
     or \a str2 is 0 (but not both).
 
     \sa qstrncmp() qstricmp() qstrnicmp()
 	\link #asciinotion Note on character comparisons \endlink
 */
 
 /*!
     \fn int qstrncmp( const char *str1, const char *str2, uint len );
 
     \relates QCString
 
     A safe strncmp() function.
 
     Compares at most \a len bytes of \a str1 and \a str2.
 
     Returns a negative value if \a str1 is less than \a str2, 0 if \a
     str1 is equal to \a str2 or a positive value if \a str1 is greater
     than \a str2.
 
     Special case I: Returns 0 if \a str1 and \a str2 are both 0.
 
     Special case II: Returns a random nonzero value if \a str1 is 0
     or \a str2 is 0 (but not both).
 
     \sa qstrcmp(), qstricmp(), qstrnicmp()
 	\link #asciinotion Note on character comparisons \endlink
 */
 
 /*!
     \relates QCString
 
     A safe stricmp() function.
 
     Compares \a str1 and \a str2 ignoring the case.
 
     Returns a negative value if \a str1 is less than \a str2, 0 if \a
     str1 is equal to \a str2 or a positive value if \a str1 is greater
     than \a str2.
 
     Special case I: Returns 0 if \a str1 and \a str2 are both 0.
 
     Special case II: Returns a random nonzero value if \a str1 is 0
     or \a str2 is 0 (but not both).
 
     \sa qstrcmp(), qstrncmp(), qstrnicmp()
 	\link #asciinotion Note on character comparisons \endlink
 */
 
 int qstricmp( const char *str1, const char *str2 )
 {
     register const uchar *s1 = (const uchar *)str1;
     register const uchar *s2 = (const uchar *)str2;
     int res;
     uchar c;
     if ( !s1 || !s2 )
 	return s1 ? 1 : ( s2 ? -1 : 0 );
     for ( ; !(res = (c=tolower(*s1)) - tolower(*s2)); s1++, s2++ )
 	if ( !c )				// strings are equal
 	    break;
     return res;
 }
 
 /*!
     \relates QCString
 
     A safe strnicmp() function.
 
     Compares at most \a len bytes of \a str1 and \a str2 ignoring the case.
 
     Returns a negative value if \a str1 is less than \a str2, 0 if \a str1
     is equal to \a str2 or a positive value if \a str1 is greater than \a
     str2.
 
     Special case I: Returns 0 if \a str1 and \a str2 are both 0.
 
     Special case II: Returns a random nonzero value if \a str1 is 0
     or \a str2 is 0 (but not both).
 
     \sa qstrcmp(), qstrncmp() qstricmp()
 	\link #asciinotion Note on character comparisons \endlink
 */
 
 int qstrnicmp( const char *str1, const char *str2, uint len )
 {
     register const uchar *s1 = (const uchar *)str1;
     register const uchar *s2 = (const uchar *)str2;
     int res;
     uchar c;
     if ( !s1 || !s2 )
 	return s1 ? 1 : ( s2 ? -1 : 0 );
     for ( ; len--; s1++, s2++ ) {
 	if ( (res = (c=tolower(*s1)) - tolower(*s2)) )
 	    return res;
 	if ( !c )				// strings are equal
 	    break;
     }
     return 0;
 }
 
 
 static Q_UINT16 crc_tbl[16];
 static bool   crc_tbl_init = FALSE;
 
 static void createCRC16Table()			// build CRC16 lookup table
 {
     register uint i;
     register uint j;
     uint v0, v1, v2, v3;
     for ( i = 0; i < 16; i++ ) {
 	v0 = i & 1;
 	v1 = ( i >> 1 ) & 1;
 	v2 = ( i >> 2 ) & 1;
 	v3 = ( i >> 3 ) & 1;
 	j = 0;
 #undef SET_BIT
 #define SET_BIT(x, b, v) (x) |= (v) << (b)
 	SET_BIT( j,  0, v0 );
 	SET_BIT( j,  7, v0 );
 	SET_BIT( j, 12, v0 );
 	SET_BIT( j,  1, v1 );
 	SET_BIT( j,  8, v1 );
 	SET_BIT( j, 13, v1 );
 	SET_BIT( j,  2, v2 );
 	SET_BIT( j,  9, v2 );
 	SET_BIT( j, 14, v2 );
 	SET_BIT( j,  3, v3 );
 	SET_BIT( j, 10, v3 );
 	SET_BIT( j, 15, v3 );
 	crc_tbl[i] = j;
     }
 }
 
 /*!
     \relates QMemArray
 
     Returns the CRC-16 checksum of \a len bytes starting at \a data.
 
     The checksum is independent of the byte order (endianness).
 */
 
 Q_UINT16 qChecksum( const char *data, uint len )
 {
     if ( !crc_tbl_init ) {			// create lookup table
 
 #ifdef QT_THREAD_SUPPORT
-	QMutexLocker locker( qt_global_mutexpool->get( &crc_tbl_init ) );
+	QMutexLocker locker( qt_global_mutexpool ?
+			     qt_global_mutexpool->get( &crc_tbl_init ) : 0 );
 #endif // QT_THREAD_SUPPORT
 
 	if ( !crc_tbl_init ) {
 	    createCRC16Table();
 	    crc_tbl_init = TRUE;
 	}
     }
     register Q_UINT16 crc = 0xffff;
     uchar c;
     uchar *p = (uchar *)data;
     while ( len-- ) {
 	c = *p++;
 	crc = ( (crc >> 4) & 0x0fff ) ^ crc_tbl[((crc ^ c) & 15)];
 	c >>= 4;
 	crc = ( (crc >> 4) & 0x0fff ) ^ crc_tbl[((crc ^ c) & 15)];
     }
     return ~crc & 0xffff;
 }
 
-/*! \fn QByteArray qCompress( const QByteArray& data)
-  \relates QByteArray
-  \overload
+/*!
+    \fn QByteArray qCompress( const QByteArray& data )
+
+    \relates QByteArray
+
+    Compresses the array \a data and returns the compressed byte
+    array.
+
+    \sa qUncompress()
 */
 
 /*!
-  \relates QByteArray
+    \relates QByteArray
 
-  Compresses the array \a data which is \a nbytes long and returns the
-  compressed byte array.
+    \overload
 
-  \sa qUncompress()
+    Compresses the array \a data which is \a nbytes long and returns the
+    compressed byte array.
 */
 
 #ifndef QT_NO_COMPRESS
 QByteArray qCompress( const uchar* data, int nbytes )
 {
     if ( nbytes == 0 ) {
 	QByteArray tmp( 4 );
 	tmp.fill( 0 );
 	return tmp;
     }
     if ( !data ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "qCompress: data is NULL." );
 #endif
 	return QByteArray();
     }
 
     ulong len = nbytes * 2;
     QByteArray bazip;
     int res;
     do {
 	bazip.resize( len + 4 );
 	res = ::compress(  (uchar*)bazip.data()+4, &len, (uchar*)data, nbytes );
 
 	switch ( res ) {
 	case Z_OK:
 	    bazip.resize( len + 4 );
 	    bazip[0] = ( nbytes & 0xff000000 ) >> 24;
 	    bazip[1] = ( nbytes & 0x00ff0000 ) >> 16;
 	    bazip[2] = ( nbytes & 0x0000ff00 ) >> 8;
 	    bazip[3] = ( nbytes & 0x000000ff );
 	    break;
 	case Z_MEM_ERROR:
 #if defined(QT_CHECK_RANGE)
 	    qWarning( "qCompress: Z_MEM_ERROR: Not enough memory." );
 #endif
 	    bazip.resize( 0 );
 	    break;
 	case Z_BUF_ERROR:
 	    len *= 2;
 	    break;
 	}
     } while ( res == Z_BUF_ERROR );
 
     return bazip;
 }
 #endif
 
-/*! \fn QByteArray qUncompress( const QByteArray& data )
-  \relates QByteArray
-  \overload
+/*!
+    \fn QByteArray qUncompress( const QByteArray& data )
+
+    \relates QByteArray
+
+    Uncompresses the array \a data and returns the uncompressed byte
+    array.
+
+    Returns an empty QByteArray if the input data was corrupt.
+    \omit
+    ADD THE FOLLOWING FOR Qt 4.0
+    This function will uncompress data compressed with qCompress()
+    from this and any earlier Qt version, back to Qt 3.1 when this
+    feature was added.
+    \endomit
+
+    \sa qCompress()
 */
 
 /*!
-  \relates QByteArray
-
-  Uncompresses the array \a data which is \a nbytes long and returns
-  the uncompressed byte array.
+    \relates QByteArray
 
-  Returns an empty QByteArray if the input data was corrupt.
+    \overload
 
-  \sa qCompress()
+    Uncompresses the array \a data which is \a nbytes long and returns
+    the uncompressed byte array.
 */
 
 #ifndef QT_NO_COMPRESS
 QByteArray qUncompress( const uchar* data, int nbytes )
 {
     if ( !data ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "qUncompress: data is NULL." );
 #endif
 	return QByteArray();
     }
     if ( nbytes <= 4 ) {
 #if defined(QT_CHECK_RANGE)
 	if ( nbytes < 4 || ( data[0]!=0 || data[1]!=0 || data[2]!=0 || data[3]!=0 ) )
 	    qWarning( "qUncompress: Input data is corrupted." );
 #endif
 	return QByteArray();
     }
     ulong expectedSize = ( data[0] << 24 ) | ( data[1] << 16 ) | ( data[2] << 8 ) | data[3];
     ulong len = QMAX( expectedSize,  1 );
     QByteArray baunzip;
     int res;
     do {
 	baunzip.resize( len );
 	res = ::uncompress( (uchar*)baunzip.data(), &len,
 				(uchar*)data+4, nbytes-4 );
 
 	switch ( res ) {
 	case Z_OK:
 	    if ( len != baunzip.size() )
 		baunzip.resize( len );
 	    break;
 	case Z_MEM_ERROR:
 #if defined(QT_CHECK_RANGE)
 	    qWarning( "qUncompress: Z_MEM_ERROR: Not enough memory." );
 #endif
 	    break;
 	case Z_BUF_ERROR:
 	    len *= 2;
 	    break;
 	case Z_DATA_ERROR:
 #if defined(QT_CHECK_RANGE)
 	    qWarning( "qUncompress: Z_DATA_ERROR: Input data is corrupted." );
 #endif
 	    break;
 	}
     } while ( res == Z_BUF_ERROR );
 
     if ( res != Z_OK )
 	baunzip = QByteArray();
 
     return baunzip;
 }
 #endif
 
 /*****************************************************************************
   QByteArray documentation
  *****************************************************************************/
 
 /*!
     \class QByteArray
     \reentrant
     \brief The QByteArray class provides an array of bytes.
 
     \ingroup collection
     \ingroup tools
 
     The QByteArray class provides an explicitly shared array of bytes.
     It is useful for manipulating memory areas with custom data.
     QByteArray is implemented as a QMemArray\<char\>. See the \l
     QMemArray documentation for further information.
 */
 
 /*!
     \fn QByteArray::QByteArray()
 
     Constructs an empty QByteArray.
 */
 
 /*!
     \fn QByteArray::QByteArray( int size )
 
     Constructs a QByteArray of size \a size.
 */
 
 /*****************************************************************************
   QByteArray stream functions
  *****************************************************************************/
 
 /*!
     \relates QMemArray
 
     Writes byte array \a a to the stream \a s and returns a reference
     to the stream.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 #ifndef QT_NO_DATASTREAM
 
 QDataStream &operator<<( QDataStream &s, const QByteArray &a )
 {
     return s.writeBytes( a.data(), a.size() );
 }
 
 /*!
     \relates QMemArray
 
     Reads a byte array into \a a from the stream \a s and returns a
     reference to the stream.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator>>( QDataStream &s, QByteArray &a )
 {
     Q_UINT32 len;
     s >> len;					// read size of array
     if ( len == 0 || s.eof() ) {		// end of file reached
 	a.resize( 0 );
 	return s;
     }
     if ( !a.resize( (uint)len ) ) {		// resize array
 #if defined(QT_CHECK_NULL)
 	qWarning( "QDataStream: Not enough memory to read QByteArray" );
 #endif
 	len = 0;
     }
     if ( len > 0 )				// not null array
 	s.readRawBytes( a.data(), (uint)len );
     return s;
 }
 
 #endif //QT_NO_DATASTREAM
 
 /*****************************************************************************
   QCString member functions
  *****************************************************************************/
 
 /*!
     \class QCString qcstring.h
     \reentrant
     \brief The QCString class provides an abstraction of the classic C
     zero-terminated char array (char *).
 
     \ingroup text
     \ingroup collection
     \ingroup tools
     \ingroup shared
 
     QCString inherits QByteArray, which is defined as
     QMemArray\<char\>. Since QCString is a QMemArray, it uses \link
     shclass.html explicit sharing\endlink with a reference count.
 
     QCString tries to behave like a more convenient \c{const char *}.
     The price of doing this is that some algorithms will perform
     badly. For example, append() is O(length()) since it scans for a
     null terminator. Although you might use QCString for text that is
     never exposed to the user, for most purposes, and especially for
     user-visible text, you should use QString. QString provides
     implicit sharing, Unicode and other internationalization support,
     and is well optimized.
 
     Note that for the QCString methods that take a \c{const char *}
     parameter the \c{const char *} must either be 0 (null) or not-null
     and '\0' (NUL byte) terminated; otherwise the results are
     undefined.
 
     A QCString that has not been assigned to anything is \e null, i.e.
     both the length and the data pointer is 0. A QCString that
     references the empty string ("", a single '\0' char) is \e empty.
     Both null and empty QCStrings are legal parameters to the methods.
     Assigning \c{const char *} 0 to QCString produces a null QCString.
 
     The length() function returns the length of the string; resize()
     resizes the string and truncate() truncates the string. A string
     can be filled with a character using fill(). Strings can be left
     or right padded with characters using leftJustify() and
     rightJustify(). Characters, strings and regular expressions can be
     searched for using find() and findRev(), and counted using
     contains().
 
     Strings and characters can be inserted with insert() and appended
     with append(). A string can be prepended with prepend().
     Characters can be removed from the string with remove() and
     replaced with replace().
 
     Portions of a string can be extracted using left(), right() and
     mid(). Whitespace can be removed using stripWhiteSpace() and
     simplifyWhiteSpace(). Strings can be converted to uppercase or
     lowercase with upper() and lower() respectively.
 
     Strings that contain numbers can be converted to numbers with
     toShort(), toInt(), toLong(), toULong(), toFloat() and toDouble().
     Numbers can be converted to strings with setNum().
 
     Many operators are overloaded to work with QCStrings. QCString
     also supports some more obscure functions, e.g. sprintf(),
     setStr() and setExpand().
 
     \target asciinotion
     \sidebar Note on Character Comparisons
 
     In QCString the notion of uppercase and lowercase and of which
     character is greater than or less than another character is locale
     dependent. This affects functions which support a case insensitive
     option or which compare or lowercase or uppercase their arguments.
     Case insensitive operations and comparisons will be accurate if
     both strings contain only ASCII characters. (If \c $LC_CTYPE is
     set, most Unix systems do "the right thing".) Functions that this
     affects include contains(), find(), findRev(), \l operator<(), \l
     operator<=(), \l operator>(), \l operator>=(), lower() and
     upper().
 
     This issue does not apply to \l{QString}s since they represent
     characters using Unicode.
     \endsidebar
 
     Performance note: The QCString methods for QRegExp searching are
     implemented by converting the QCString to a QString and performing
     the search on that. This implies a deep copy of the QCString data.
     If you are going to perform many QRegExp searches on a large
     QCString, you will get better performance by converting the
     QCString to a QString yourself, and then searching in the QString.
 */
 
 /*!
     \fn QCString::QCString()
 
     Constructs a null string.
 
     \sa isNull()
 */
 
 /*!
     \fn QCString::QCString( const QCString &s )
 
     Constructs a shallow copy \a s.
 
     \sa assign()
 */
 
 /*!
     Constructs a string with room for \a size characters, including
     the '\0'-terminator. Makes a null string if \a size == 0.
 
     If \a size \> 0, then the first and last characters in the string
     are initialized to '\0'. All other characters are uninitialized.
 
     \sa resize(), isNull()
 */
 
 QCString::QCString( int size )
     : QByteArray( size )
 {
     if ( size > 0 ) {
 	*data() = '\0';				// set terminator
 	*(data()+(size-1)) = '\0';
     }
 }
 
 /*!
     Constructs a string that is a deep copy of \a str.
 
     If \a str is 0 a null string is created.
 
     \sa isNull()
 */
 
 QCString::QCString( const char *str )
 {
     duplicate( str, qstrlen(str) + 1 );
 }
 
 
 /*!
     Constructs a string that is a deep copy of \a str. The copy will
     be at most \a maxsize bytes long including the '\0'-terminator.
 
     Example:
     \code
     QCString str( "helloworld", 6 ); // assigns "hello" to str
     \endcode
 
     If \a str contains a 0 byte within the first \a maxsize bytes, the
     resulting QCString will be terminated by this 0. If \a str is 0 a
     null string is created.
 
     \sa isNull()
 */
 
 QCString::QCString( const char *str, uint maxsize )
 {
     if ( str == 0 )
 	return;
     uint len; // index of first '\0'
     for ( len = 0; len < maxsize - 1; len++ ) {
 	if ( str[len] == '\0' )
 	    break;
     }
     QByteArray::resize( len + 1 );
     memcpy( data(), str, len );
     data()[len] = 0;
 }
 
 /*!
   \reimp
 */
 
 QCString::~QCString()
 {
 }
 
 /*!
     \fn QCString &QCString::operator=( const QCString &s )
 
     Assigns a shallow copy of \a s to this string and returns a
     reference to this string.
 */
 
 /*!
     \overload QCString &QCString::operator=( const char *str )
 
     Assigns a deep copy of \a str to this string and returns a
     reference to this string.
 
     If \a str is 0 a null string is created.
 
     \sa isNull()
 */
 
 /*!
     \fn bool QCString::isNull() const
 
     Returns TRUE if the string is null, i.e. if data() == 0; otherwise
     returns FALSE. A null string is also an empty string.
 
     Example:
     \code
     QCString a;		// a.data() == 0,  a.size() == 0, a.length() == 0
     QCString b == "";	// b.data() == "", b.size() == 1, b.length() == 0
     a.isNull();		// TRUE  because a.data() == 0
     a.isEmpty();	// TRUE  because a.length() == 0
     b.isNull();		// FALSE because b.data() == ""
     b.isEmpty();	// TRUE  because b.length() == 0
     \endcode
 
     \sa isEmpty(), length(), size()
 */
 
 /*!
     \fn bool QCString::isEmpty() const
 
     Returns TRUE if the string is empty, i.e. if length() == 0;
     otherwise returns FALSE. An empty string is not always a null
     string.
 
     See example in isNull().
 
     \sa isNull(), length(), size()
 */
 
 /*!
     \fn uint QCString::length() const
 
     Returns the length of the string, excluding the '\0'-terminator.
     Equivalent to calling \c strlen(data()).
 
     Null strings and empty strings have zero length.
 
     \sa size(), isNull(), isEmpty()
 */
 
 /*!
     \fn bool QCString::truncate( uint pos )
 
     Truncates the string at position \a pos.
 
     Equivalent to calling \c resize(pos+1).
 
     Example:
     \code
     QCString s = "truncate this string";
     s.truncate( 5 );                      // s == "trunc"
     \endcode
 
     \sa resize()
 */
 
 /*!
     Extends or shrinks the string to \a len bytes, including the
     '\0'-terminator.
 
     A '\0'-terminator is set at position \c{len - 1} unless
     \c{len == 0}.
 
     Example:
     \code
     QCString s = "resize this string";
     s.resize( 7 );                      // s == "resize"
     \endcode
 
     \sa truncate()
 */
 
 bool QCString::resize( uint len )
 {
     detach();
     uint wasNull = isNull();
     if ( !QByteArray::resize(len) )
 	return FALSE;
     if ( len )
 	data()[len - 1] = '\0';
     if ( len > 0 && wasNull )
 	data()[0] = '\0';
     return TRUE;
 }
 
 
 /*!
     Implemented as a call to the native vsprintf() (see the manual for
     your C library).
 
     If the string is shorter than 256 characters, this sprintf() calls
     resize(256) to decrease the chance of memory corruption. The
     string is resized back to its actual length before sprintf()
     returns.
 
     Example:
     \code
     QCString s;
     s.sprintf( "%d - %s", 1, "first" );		// result < 256 chars
 
     QCString big( 25000 );			// very long string
     big.sprintf( "%d - %s", 2, longString );	// result < 25000 chars
     \endcode
 
     \warning All vsprintf() implementations will write past the end of
     the target string (*this) if the \a format specification and
     arguments happen to be longer than the target string, and some
     will also fail if the target string is longer than some arbitrary
     implementation limit.
 
     Giving user-supplied arguments to sprintf() is risky: Sooner or
     later someone will paste a huge line into your application.
 */
 
 QCString &QCString::sprintf( const char *format, ... )
 {
     detach();
     va_list ap;
     va_start( ap, format );
     if ( size() < 256 )
 	QByteArray::resize( 256 );		// make string big enough
     vsprintf( data(), format, ap );
     resize( qstrlen(data()) + 1 );		// truncate
     va_end( ap );
     return *this;
 }
 
 
 /*!
     Fills the string with \a len bytes of character \a c, followed by
     a '\0'-terminator.
 
     If \a len is negative, then the current string length is used.
 
     Returns FALSE is \a len is nonnegative and there is not enough
     memory to resize the string; otherwise returns TRUE.
 */
 
 bool QCString::fill( char c, int len )
 {
     detach();
     if ( len < 0 )
 	len = length();
     if ( !QByteArray::fill(c,len+1) )
 	return FALSE;
     *(data()+len) = '\0';
     return TRUE;
 }
 
 
 /*!
     \fn QCString QCString::copy() const
 
     Returns a deep copy of this string.
 
     \sa detach()
 */
 
 
 /*!
     Finds the first occurrence of the character \a c, starting at
     position \a index.
 
     The search is case sensitive if \a cs is TRUE, or case insensitive
     if \a cs is FALSE.
 
     Returns the position of \a c, or -1 if \a c could not be found.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 int QCString::find( char c, int index, bool cs ) const
 {
     if ( (uint)index >= size() )		// index outside string
 	return -1;
     register const char *d;
     if ( cs ) {					// case sensitive
 	d = strchr( data()+index, c );
     } else {
 	d = data()+index;
 	c = tolower( (uchar) c );
 	while ( *d && tolower((uchar) *d) != c )
 	    d++;
 	if ( !*d && c )				// not found
 	    d = 0;
     }
     return d ? (int)(d - data()) : -1;
 }
 
 #define REHASH( a ) \
     if ( sl_minus_1 < sizeof(uint) * CHAR_BIT ) \
 	hashHaystack -= (a) << sl_minus_1; \
     hashHaystack <<= 1
 
 /*!
     \overload
 
     Finds the first occurrence of the string \a str, starting at
     position \a index.
 
     The search is case sensitive if \a cs is TRUE, or case insensitive
     if \a cs is FALSE.
 
     Returns the position of \a str, or -1 if \a str could not be
     found.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 int QCString::find( const char *str, int index, bool cs ) const
 {
+    return find( str, index, cs, length() );
+}
+
+int QCString::find( const char *str, int index, bool cs, uint l ) const
+{
     if ( (uint)index >= size() )
 	return -1;
     if ( !str )
 	return -1;
     if ( !*str )
 	return index;
-    const uint l = length();
     const uint sl = qstrlen( str );
     if ( sl + index > l )
 	return -1;
 
     if ( sl == 1 )
 	return find( *str, index, cs );
 
     /*
       See QString::find() for details.
     */
     const char* needle = str;
     const char* haystack = data() + index;
     const char* end = data() + (l-sl);
     const uint sl_minus_1 = sl-1;
     uint hashNeedle = 0, hashHaystack = 0,i;
 
     if ( cs ) {
 	for ( i = 0; i < sl; ++i ) {
 	    hashNeedle = ((hashNeedle<<1) + needle[i] );
 	    hashHaystack = ((hashHaystack<<1) + haystack[i] );
 	}
 	hashHaystack -= *(haystack+sl_minus_1);
 
 	while ( haystack <= end ) {
 	    hashHaystack += *(haystack+sl_minus_1);
  	    if ( hashHaystack == hashNeedle  && *needle == *haystack
 		 && qstrncmp( needle, haystack, sl ) == 0 )
 		return haystack - data();
 
 	    REHASH( *haystack );
 	    ++haystack;
 	}
     } else {
 	for ( i = 0; i < sl; ++i ) {
 	    hashNeedle = ((hashNeedle<<1) +
 			  tolower( needle[i] ) );
 	    hashHaystack = ((hashHaystack<<1) +
 			    tolower( haystack[i] ) );
 	}
 	hashHaystack -= tolower(*(haystack+sl_minus_1));
 
 	while ( haystack <= end ) {
 	    hashHaystack += tolower(*(haystack+sl_minus_1));
 	    if ( hashHaystack == hashNeedle
 		 && qstrnicmp( needle, haystack, sl ) == 0 )
 		return haystack - data();
 
 	    REHASH( tolower(*haystack) );
 	    ++haystack;
 	}
     }
     return -1;
 }
 
 
 /*!
     Finds the first occurrence of the character \a c, starting at
     position \a index and searching backwards.
 
     The search is case sensitive if \a cs is TRUE, or case insensitive
     if \a cs is FALSE.
 
     Returns the position of \a c, or -1 if \a c could not be found.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 int QCString::findRev( char c, int index, bool cs ) const
 {
     register const char *b = data();
     register const char *d;
     if ( index < 0 )
 	index = length();
     if ( (uint)index >= size() )
 	return -1;
     d = b + index;
     if ( cs ) {
 	while ( d >= b && *d != c )
 	    d--;
     } else {
 	c = tolower( (uchar) c );
 	while ( d >= b && tolower((uchar) *d) != c )
 	    d--;
     }
     return d >= b ? (int)(d - b) : -1;
 }
 
 /*!
     \overload
 
     Finds the first occurrence of the string \a str, starting at
     position \a index and searching backwards.
 
     The search is case sensitive if \a cs is TRUE, or case insensitive
     if \a cs is FALSE.
 
     Returns the position of \a str, or -1 if \a str could not be
     found.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 int QCString::findRev( const char *str, int index, bool cs ) const
 {
     /*
       See QString::find() for explanations.
     */
     const uint sl = qstrlen( str );
     const uint l = length();
     int delta = l-sl;
     if ( index < 0 )
 	index = delta;
     if ( index < 0 || index > (int)l )
 	return -1;
     if ( index > delta )
 	index = delta;
 
     if ( sl == 1 )
 	return findRev( *str, index, cs );
 
     const char* needle = str;
     const char* haystack = data() + index;
     const char* end = data();
     const uint sl_minus_1 = sl-1;
     const char* n = needle+sl_minus_1;
     const char* h = haystack+sl_minus_1;
     uint hashNeedle = 0, hashHaystack = 0, i;
 
     if ( cs ) {
 	for ( i = 0; i < sl; ++i ) {
 	    hashNeedle = ((hashNeedle<<1) + *(n-i) );
 	    hashHaystack = ((hashHaystack<<1) + *(h-i) );
 	}
 	hashHaystack -= *haystack;
 	while ( haystack >= end ) {
 	    hashHaystack += *haystack;
  	    if ( hashHaystack == hashNeedle  && qstrncmp( needle, haystack, sl ) == 0 )
 		return haystack-data();
 	    --haystack;
 	    REHASH( *(haystack+sl) );
 	}
     } else {
 	for ( i = 0; i < sl; ++i ) {
 	    hashNeedle = ((hashNeedle<<1) + tolower( *(n-i) ) );
 	    hashHaystack = ((hashHaystack<<1) + tolower( *(h-i) ) );
 	}
 	hashHaystack -= tolower(*haystack);
 	while ( haystack >= end ) {
 	    hashHaystack += tolower(*haystack);
 	    if ( hashHaystack == hashNeedle && qstrnicmp( needle, haystack, sl ) == 0 )
 		return haystack-data();
 	    --haystack;
 	    REHASH( tolower(*(haystack+sl)) );
 	}
     }
     return -1;
 }
 
 
 /*!
     Returns the number of times the character \a c occurs in the
     string.
 
     The match is case sensitive if \a cs is TRUE, or case insensitive
     if \a cs if FALSE.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 int QCString::contains( char c, bool cs ) const
 {
     int count = 0;
     char *d = data();
     if ( !d )
 	return 0;
     if ( cs ) {					// case sensitive
 	while ( *d )
 	    if ( *d++ == c )
 		count++;
     } else {					// case insensitive
 	c = tolower( (uchar) c );
 	while ( *d ) {
 	    if ( tolower((uchar) *d) == c )
 		count++;
 	    d++;
 	}
     }
     return count;
 }
 
 /*!
     \overload
 
     Returns the number of times \a str occurs in the string.
 
     The match is case sensitive if \a cs is TRUE, or case insensitive
     if \a cs if FALSE.
 
     This function counts overlapping substrings, for example, "banana"
     contains two occurrences of "ana".
 
     \sa findRev()
 	\link #asciinotion Note on character comparisons \endlink
 */
 
 int QCString::contains( const char *str, bool cs ) const
 {
     int count = 0;
     int i = -1;
+    uint l = length();
     // use find for the faster hashing algorithm
-    while ( ( i = find ( str, i+1, cs ) ) != -1 )
+    while ( ( i = find ( str, i+1, cs, l ) ) != -1 )
 	count++;
     return count;
 }
 
 /*!
     Returns a substring that contains the \a len leftmost characters
     of the string.
 
     The whole string is returned if \a len exceeds the length of the
     string.
 
     Example:
     \code
     QCString s = "Pineapple";
     QCString t = s.left( 4 );  // t == "Pine"
     \endcode
 
     \sa right(), mid()
 */
-
 QCString QCString::left( uint len ) const
 {
     if ( isEmpty() ) {
 	QCString empty;
 	return empty;
     } else if ( len >= size() ) {
 	QCString same( data() );
 	return same;
     } else {
 	QCString s( len+1 );
 	strncpy( s.data(), data(), len );
 	*(s.data()+len) = '\0';
 	return s;
     }
 }
 
 /*!
     Returns a substring that contains the \a len rightmost characters
     of the string.
 
     The whole string is returned if \a len exceeds the length of the
     string.
 
     Example:
     \code
     QCString s = "Pineapple";
     QCString t = s.right( 5 );  // t == "apple"
     \endcode
 
     \sa left(), mid()
 */
 
 QCString QCString::right( uint len ) const
 {
     if ( isEmpty() ) {
 	QCString empty;
 	return empty;
     } else {
 	uint l = length();
 	if ( len > l )
 	    len = l;
 	char *p = data() + (l - len);
 	return QCString( p );
     }
 }
 
 /*!
     Returns a substring that contains at most \a len characters from
     this string, starting at position \a index.
 
     Returns a null string if the string is empty or if \a index is out
     of range. Returns the whole string from \a index if \a index+len
     exceeds the length of the string.
 
     Example:
     \code
     QCString s = "Two pineapples";
     QCString t = s.mid( 4, 3 );     // t == "pin"
     \endcode
 
     \sa left(), right()
 */
 
 QCString QCString::mid( uint index, uint len ) const
 {
     uint slen = qstrlen( data() );
     if ( isEmpty() || index >= slen ) {
 	QCString empty;
 	return empty;
     } else {
 	if ( len > slen-index )
 	    len = slen - index;
 	register char *p = data()+index;
 	QCString s( len+1 );
 	strncpy( s.data(), p, len );
 	*(s.data()+len) = '\0';
 	return s;
     }
 }
 
 /*!
     Returns a string of length \a width (plus one for the terminating
     '\0') that contains this string padded with the \a fill character.
 
     If the length of the string exceeds \a width and \a truncate is
     FALSE (the default), then the returned string is a copy of the
     string. If the length of the string exceeds \a width and \a
     truncate is TRUE, then the returned string is a left(\a width).
 
     Example:
     \code
     QCString s("apple");
     QCString t = s.leftJustify(8, '.');  // t == "apple..."
     \endcode
 
     \sa rightJustify()
 */
 
 QCString QCString::leftJustify( uint width, char fill, bool truncate ) const
 {
     QCString result;
     int len = qstrlen(data());
     int padlen = width - len;
     if ( padlen > 0 ) {
 	result.QByteArray::resize( len+padlen+1 );
 	memcpy( result.data(), data(), len );
 	memset( result.data()+len, fill, padlen );
 	result[len+padlen] = '\0';
     } else {
 	if ( truncate )
 	    result = left( width );
 	else
 	    result = copy();
     }
     return result;
 }
 
 /*!
     Returns a string of length \a width (plus one for the terminating
     '\0') that contains zero or more of the \a fill character followed
     by this string.
 
     If the length of the string exceeds \a width and \a truncate is
     FALSE (the default), then the returned string is a copy of the
     string. If the length of the string exceeds \a width and \a
     truncate is TRUE, then the returned string is a left(\a width).
 
     Example:
     \code
     QCString s("pie");
     QCString t = s.rightJustify(8, '.');  // t == ".....pie"
     \endcode
 
     \sa leftJustify()
 */
 
 QCString QCString::rightJustify( uint width, char fill, bool truncate ) const
 {
     QCString result;
     int len = qstrlen(data());
     int padlen = width - len;
     if ( padlen > 0 ) {
 	result.QByteArray::resize( len+padlen+1 );
 	memset( result.data(), fill, padlen );
 	memcpy( result.data()+padlen, data(), len );
 	result[len+padlen] = '\0';
     } else {
 	if ( truncate )
 	    result = left( width );
 	else
 	    result = copy();
     }
     return result;
 }
 
 /*!
     Returns a new string that is a copy of this string converted to lower
     case.
 
     Example:
     \code
     QCString s("Credit");
     QCString t = s.lower();  // t == "credit"
     \endcode
 
     \sa upper()
       \link #asciinotion Note on character comparisons \endlink
 */
 
 QCString QCString::lower() const
 {
     QCString s( data() );
     register char *p = s.data();
     if ( p ) {
 	while ( *p ) {
 	    *p = tolower( (uchar) *p );
 	    p++;
 	}
     }
     return s;
 }
 
 /*!
     Returns a new string that is a copy of this string converted to upper case.
 
     Example:
     \code
     QCString s( "Debit" );
     QCString t = s.upper();  // t == "DEBIT"
     \endcode
 
     \sa lower()
       \link #asciinotion Note on character comparisons \endlink
 */
 
 QCString QCString::upper() const
 {
     QCString s( data() );
     register char *p = s.data();
     if ( p ) {
 	while ( *p ) {
 	    *p = toupper(*p);
 	    p++;
 	}
     }
     return s;
 }
 
 
 /*!
     Returns a new string that has white space removed from the start
     and the end.
 
     White space means the decimal ASCII codes 9, 10, 11, 12, 13 and
     32.
 
     Example:
     \code
     QCString s = " space ";
     QCString t = s.stripWhiteSpace();		// t == "space"
     \endcode
 
     \sa simplifyWhiteSpace()
 */
 
 QCString QCString::stripWhiteSpace() const
 {
     if ( isEmpty() )				// nothing to do
 	return copy();
 
     register char *s = data();
     QCString result = s;
     int reslen = result.length();
     if ( !isspace((uchar) s[0]) && !isspace((uchar) s[reslen-1]) )
 	return result;				// returns a copy
 
     s = result.data();
     int start = 0;
     int end = reslen - 1;
     while ( isspace((uchar) s[start]) )		// skip white space from start
 	start++;
     if ( s[start] == '\0' ) {			// only white space
 	result.resize( 1 );
 	return result;
     }
     while ( end && isspace((uchar) s[end]) )	// skip white space from end
 	end--;
     end -= start - 1;
     memmove( result.data(), &s[start], end );
     result.resize( end + 1 );
     return result;
 }
 
 
 /*!
     Returns a new string that has white space removed from the start
     and the end, plus any sequence of internal white space replaced
     with a single space (ASCII 32).
 
     White space means the decimal ASCII codes 9, 10, 11, 12, 13 and
     32.
 
     \code
     QCString s = "  lots\t of\nwhite    space ";
     QCString t = s.simplifyWhiteSpace(); // t == "lots of white space"
     \endcode
 
     \sa stripWhiteSpace()
 */
 
 QCString QCString::simplifyWhiteSpace() const
 {
     if ( isEmpty() )				// nothing to do
 	return copy();
     QCString result( size() );
     char *from	= data();
     char *to	= result.data();
     char *first = to;
     for ( ;; ) {
 	while ( isspace((uchar) *from) )
 	    from++;
 	while ( *from && !isspace((uchar) *from) )
 	    *to++ = *from++;
 	if ( *from )
 	    *to++ = 0x20;			// ' '
 	else
 	    break;
     }
     if ( to > first && *(to-1) == 0x20 )
 	to--;
     *to = '\0';
     result.resize( (int)(to - result.data()) + 1 );
     return result;
 }
 
 
 /*!
     \overload
 
     Inserts string \a s into the string at position \a index.
 
     If \a index is beyond the end of the string, the string is
     padded with spaces (ASCII 32) to length \a index and then \a s
     is appended.
 
     \code
     QCString s = "I like fish";
     s.insert( 2, "don't ");     // s == "I don't like fish"
 
     s = "x";                    // index 01234
     s.insert( 3, "yz" );        // s == "x  yz"
     \endcode
 */
 
 QCString &QCString::insert( uint index, const char *s )
 {
     int len = qstrlen(s);
     if ( len == 0 )
 	return *this;
     uint olen = length();
     int nlen = olen + len;
     if ( index >= olen ) {			// insert after end of string
 	detach();
-	if ( QByteArray::resize(nlen+index-olen+1) ) {
+	if ( QByteArray::resize(nlen+index-olen+1, QByteArray::SpeedOptim ) ) {
 	    memset( data()+olen, ' ', index-olen );
 	    memcpy( data()+index, s, len+1 );
 	}
-    } else if ( QByteArray::resize(nlen+1) ) {	// normal insert
+    } else {
 	detach();
-	memmove( data()+index+len, data()+index, olen-index+1 );
-	memcpy( data()+index, s, len );
+	if ( QByteArray::resize(nlen+1, QByteArray::SpeedOptim ) ) {	// normal insert
+	    memmove( data()+index+len, data()+index, olen-index+1 );
+	    memcpy( data()+index, s, len );
+	}
     }
     return *this;
 }
 
 /*!
     Inserts character \a c into the string at position \a index and
     returns a reference to the string.
 
     If \a index is beyond the end of the string, the string is
     padded with spaces (ASCII 32) to length \a index and then \a c
     is appended.
 
     Example:
     \code
     QCString s = "Yes";
     s.insert( 3, '!');   // s == "Yes!"
     \endcode
 
     \sa remove(), replace()
 */
 
 QCString &QCString::insert( uint index, char c )	// insert char
 {
     char buf[2];
     buf[0] = c;
     buf[1] = '\0';
     return insert( index, buf );
 }
 
 /*!
     \fn QCString &QCString::prepend( const char *s )
 
     Prepend \a s to the string. Equivalent to insert(0, s).
 
     \sa insert()
 */
 
 /*!
     Removes \a len characters from the string, starting at position \a
     index, and returns a reference to the string.
 
     If \a index is out of range, nothing happens. If \a index is
     valid, but \a index + \a len is larger than the length of the
     string, the string is truncated at position \a index.
 
     \code
     QCString s = "Montreal";
     s.remove( 1, 4 );         // s == "Meal"
     \endcode
 
     \sa insert(), replace()
 */
 
 QCString &QCString::remove( uint index, uint len )
 {
     uint olen = length();
     if ( index + len >= olen ) {		// range problems
 	if ( index < olen ) {			// index ok
 	    detach();
 	    resize( index+1 );
 	}
     } else if ( len != 0 ) {
 	detach();
 	memmove( data()+index, data()+index+len, olen-index-len+1 );
-	QByteArray::resize(olen-len+1);
+	QByteArray::resize(olen-len+1, QByteArray::SpeedOptim );
     }
     return *this;
 }
 
 /*!
     Replaces \a len characters from the string, starting at position
     \a index, with \a str, and returns a reference to the string.
 
     If \a index is out of range, nothing is removed and \a str is
     appended at the end of the string. If \a index is valid, but \a
     index + \a len is larger than the length of the string, \a str
     replaces the rest of the string from position \a index.
 
     \code
     QCString s = "Say yes!";
     s.replace( 4, 3, "NO" );  // s == "Say NO!"
     \endcode
 
     \sa insert(), remove()
 */
 
 QCString &QCString::replace( uint index, uint len, const char *str )
 {
     remove( index, len );
     insert( index, str );
     return *this;
 }
 
 
 /*! \overload
 
     Replaces every occurrence of the character \a c in the string
     with \a after. Returns a reference to the string.
 
     Example:
     \code
     QCString s = "a,b,c";
     s.replace( ',', " or " );
     // s == "a or b or c"
     \endcode
 */
 QCString &QCString::replace( char c, const char *after )
 {
     char str[2];
     str[0] = c;
     str[1] = '\0';
     return replace( str, after );
 }
 
 /*! \overload
 
     Replaces every occurrence of the string \a before in the string
     with the string \a after. Returns a reference to the string.
 
     Example:
     \code
     QCString s = "Greek is Greek";
     s.replace( "Greek", "English" );
     // s == "English is English"
     \endcode
 */
+
 QCString &QCString::replace( const char *before, const char *after )
 {
     if ( before == after || isNull() )
 	return *this;
 
     detach();
 
     int index = 0;
     const int bl = before ? strlen( before ) : 0;
     const int al = after ? strlen( after ) : 0;
     char *d = data();
     uint len = length();
 
     if ( bl == al ) {
 	if ( bl ) {
-	    while( (index = find( before, index ) ) != -1 ) {
+	    while( (index = find( before, index, TRUE, len ) ) != -1 ) {
 		memcpy( d+index, after, al );
 		index += bl;
 	    }
 	}
     } else if ( al < bl ) {
 	uint to = 0;
 	uint movestart = 0;
 	uint num = 0;
-	while( (index = find( before, index ) ) != -1 ) {
+	while( (index = find( before, index, TRUE, len ) ) != -1 ) {
 	    if ( num ) {
 		int msize = index - movestart;
 		if ( msize > 0 ) {
 		    memmove( d + to, d + movestart, msize );
 		    to += msize;
 		}
 	    } else {
 		to = index;
 	    }
 	    if ( al ) {
 		memcpy( d + to, after, al );
 		to += al;
 	    }
 	    index += bl;
 	    movestart = index;
 	    num++;
 	}
 	if ( num ) {
 	    int msize = len - movestart;
 	    if ( msize > 0 )
 		memmove( d + to, d + movestart, msize );
 	    resize( len - num*(bl-al) + 1 );
 	}
     } else {
 	// the most complex case. We don't want to loose performance by doing repeated
 	// copies and reallocs of the string.
 	while( index != -1 ) {
 	    uint indices[4096];
 	    uint pos = 0;
 	    while( pos < 4095 ) {
-		index = find(before, index);
+		index = find(before, index, TRUE, len);
 		if ( index == -1 )
 		    break;
 		indices[pos++] = index;
 		index += bl;
 		// avoid infinite loop
 		if ( !bl )
 		    index++;
 	    }
 	    if ( !pos )
 		break;
 
 	    // we have a table of replacement positions, use them for fast replacing
 	    int adjust = pos*(al-bl);
 	    // index has to be adjusted in case we get back into the loop above.
 	    if ( index != -1 )
 		index += adjust;
 	    uint newlen = len + adjust;
 	    int moveend = len;
 	    if ( newlen > len ) {
 		resize( newlen + 1 );
 		len = newlen;
 	    }
 	    d = data();
 
 	    while( pos ) {
 		pos--;
 		int movestart = indices[pos] + bl;
 		int insertstart = indices[pos] + pos*(al-bl);
 		int moveto = insertstart + al;
 		memmove( d + moveto, d + movestart, (moveend - movestart) );
 		if ( after )
 		    memcpy( d + insertstart, after, al );
 		moveend = movestart - bl;
 	    }
 	}
     }
     return *this;
 }
 
 /*! \overload
 
   Replaces every occurrence of \a c1 with the char \a c2.
   Returns a reference to the string.
 */
 QCString &QCString::replace( char c1, char c2 )
 {
     detach();
     uint i = 0;
     char *d = data();
     uint len = length();
     while ( i < len ) {
 	if ( d[i] == c1 )
 	    d[i] = c2;
 	i++;
     }
     return *this;
 }
 
 
 #ifndef QT_NO_REGEXP_CAPTURE
 /*!
     \overload
 
     Finds the first occurrence of the regular expression \a rx,
     starting at position \a index.
 
     Returns the position of the next match, or -1 if \a rx was not
     found.
 
     \warning If you want to apply this function repeatedly to the same
     string it is more efficient to convert the string to a QString and
     apply the function to that.
 */
 
 int QCString::find( const QRegExp& rx, int index ) const
 {
-    QString d = QString::fromLatin1( data() );
+    QString d = QString::fromAscii( data() );
     return d.find( rx, index );
 }
 
 /*!
     \overload
 
     Finds the first occurrence of the regular expression \a rx,
     starting at position \a index and searching backwards.
 
     Returns the position of the next match (backwards), or -1 if \a rx
     was not found.
 
     \warning If you want to apply this function repeatedly to the same
     string it is more efficient to convert the string to a QString and
     apply the function to that.
 */
 
 int QCString::findRev( const QRegExp& rx, int index ) const
 {
-    QString d = QString::fromLatin1( data() );
+    QString d = QString::fromAscii( data() );
     return d.findRev( rx, index );
 }
 
 /*!
     \overload
 
     Counts the number of overlapping occurrences of \a rx in the string.
 
     Example:
     \code
     QString s = "banana and panama";
     QRegExp r = QRegExp( "a[nm]a", TRUE, FALSE );
     s.contains( r ); // 4 matches
     \endcode
 
     \sa find(), findRev()
 
     \warning If you want to apply this function repeatedly to the same
     string it is more efficient to convert the string to a QString and
     apply the function to that.
 */
 
 int QCString::contains( const QRegExp &rx ) const
 {
-    QString d = QString::fromLatin1( data() );
+    QString d = QString::fromAscii( data() );
     return d.contains( rx );
 }
 
 
 /*!
     \overload
 
     Replaces every occurrence of \a rx in the string with \a str.
     Returns a reference to the string.
 
     Example:
     \code
     QString s = "banana";
     s.replace( QRegExp("a.*a"), "" );     // becomes "b"
 
     s = "banana";
     s.replace( QRegExp("^[bn]a"), "X" );  // becomes "Xnana"
 
     s = "banana";
     s.replace( QRegExp("^[bn]a"), "" );   // becomes "nana"
     \endcode
 
     \warning If you want to apply this function repeatedly to the same
     string it is more efficient to convert the string to a QString and
     apply the function to that.
 */
 
 QCString &QCString::replace( const QRegExp &rx, const char *str )
 {
-    QString d = QString::fromLatin1( data() );
-    QString r = QString::fromLatin1( str );
+    QString d = QString::fromAscii( data() );
+    QString r = QString::fromAscii( str );
     d.replace( rx, r );
     setStr( d.ascii() );
     return *this;
 }
 #endif //QT_NO_REGEXP
 
 /*!
     Returns the string converted to a \c long value.
 
     If \a ok is not 0: \a *ok is set to FALSE if the string is not a
     number, or if it has trailing garbage; otherwise \a *ok is set to
     TRUE.
 */
 
 long QCString::toLong( bool *ok ) const
 {
     char *p = data();
     long val=0;
     const long max_mult = 214748364;
     bool is_ok = FALSE;
     int neg = 0;
     if ( !p )
 	goto bye;
     while ( isspace((uchar) *p) )		// skip leading space
 	p++;
     if ( *p == '-' ) {
 	p++;
 	neg = 1;
     } else if ( *p == '+' ) {
 	p++;
     }
     if ( !isdigit((uchar) *p) )
 	goto bye;
     while ( isdigit((uchar) *p) ) {
 	if ( val > max_mult || (val == max_mult && (*p-'0') > 7+neg) )
 	    goto bye;
 	val = 10*val + (*p++ - '0');
     }
     if ( neg )
 	val = -val;
     while ( isspace((uchar) *p) )		// skip trailing space
 	p++;
     if ( *p == '\0' )
 	is_ok = TRUE;
 bye:
     if ( ok )
 	*ok = is_ok;
     return is_ok ? val : 0;
 }
 
 /*!
     Returns the string converted to an \c{unsigned long} value.
 
     If \a ok is not 0: \a *ok is set to FALSE if the string is not a
     number, or if it has trailing garbage; otherwise \a *ok is set to
     TRUE.
 */
 
 ulong QCString::toULong( bool *ok ) const
 {
     char *p = data();
     ulong val=0;
     const ulong max_mult = 429496729;
     bool is_ok = FALSE;
     if ( !p )
 	goto bye;
     while ( isspace((uchar) *p) )		// skip leading space
 	p++;
     if ( *p == '+' )
 	p++;
     if ( !isdigit((uchar) *p) )
 	goto bye;
     while ( isdigit((uchar) *p) ) {
 	if ( val > max_mult || (val == max_mult && (*p-'0') > 5) )
 	    goto bye;
 	val = 10*val + (*p++ - '0');
     }
     while ( isspace((uchar) *p) )		// skip trailing space
 	p++;
     if ( *p == '\0' )
 	is_ok = TRUE;
 bye:
     if ( ok )
 	*ok = is_ok;
     return is_ok ? val : 0;
 }
 
 /*!
     Returns the string converted to a \c{short} value.
 
     If \a ok is not 0: \a *ok is set to FALSE if the string is not a
     number, is out of range, or if it has trailing garbage; otherwise
     \a *ok is set to TRUE.
 */
 
 short QCString::toShort( bool *ok ) const
 {
     long v = toLong( ok );
     if ( ok && *ok && (v < -32768 || v > 32767) )
 	*ok = FALSE;
     return (short)v;
 }
 
 /*!
     Returns the string converted to an \c{unsigned short} value.
 
     If \a ok is not 0: \a *ok is set to FALSE if the string is not a
     number, is out of range, or if it has trailing garbage; otherwise
     \a *ok is set to TRUE.
 */
 
 ushort QCString::toUShort( bool *ok ) const
 {
     ulong v = toULong( ok );
     if ( ok && *ok && (v > 65535) )
 	*ok = FALSE;
     return (ushort)v;
 }
 
 
 /*!
     Returns the string converted to a \c{int} value.
 
     If \a ok is not 0: \a *ok is set to FALSE if the string is not a
     number, or if it has trailing garbage; otherwise \a *ok is set to
     TRUE.
 */
 
 int QCString::toInt( bool *ok ) const
 {
     return (int)toLong( ok );
 }
 
 /*!
     Returns the string converted to an \c{unsigned int} value.
 
     If \a ok is not 0: \a *ok is set to FALSE if the string is not a
     number, or if it has trailing garbage; otherwise \a *ok is set to
     TRUE.
 */
 
 uint QCString::toUInt( bool *ok ) const
 {
     return (uint)toULong( ok );
 }
 
 /*!
     Returns the string converted to a \c{double} value.
 
     If \a ok is not 0: \a *ok is set to FALSE if the string is not a
     number, or if it has trailing garbage; otherwise \a *ok is set to
     TRUE.
 */
 
 double QCString::toDouble( bool *ok ) const
 {
     char *end;
     double val = strtod( data() ? data() : "", &end );
     if ( ok )
 	*ok = ( data() && *data() && ( end == 0 || *end == '\0' ) );
     return val;
 }
 
 /*!
     Returns the string converted to a \c{float} value.
 
     If \a ok is not 0: \a *ok is set to FALSE if the string is not a
     number, or if it has trailing garbage; otherwise \a *ok is set to
     TRUE.
 */
 
 float QCString::toFloat( bool *ok ) const
 {
     return (float)toDouble( ok );
 }
 
 
 /*!
     Makes a deep copy of \a str. Returns a reference to the string.
 */
 
 QCString &QCString::setStr( const char *str )
 {
     detach();
     if ( str )					// valid string
 	store( str, qstrlen(str)+1 );
     else					// empty
 	resize( 0 );
     return *this;
 }
 
 /*!
     \overload
 
     Sets the string to the string representation of the number \a n
     and returns a reference to the string.
 */
 
 QCString &QCString::setNum( long n )
 {
     detach();
     char buf[20];
     register char *p = &buf[19];
     bool neg;
     if ( n < 0 ) {
 	neg = TRUE;
 	n = -n;
     } else {
 	neg = FALSE;
     }
     *p = '\0';
     do {
 	*--p = ((int)(n%10)) + '0';
 	n /= 10;
     } while ( n );
     if ( neg )
 	*--p = '-';
     store( p, qstrlen(p)+1 );
     return *this;
 }
 
 /*!
     \overload
 
     Sets the string to the string representation of the number \a n
     and returns a reference to the string.
 */
 
 QCString &QCString::setNum( ulong n )
 {
     detach();
     char buf[20];
     register char *p = &buf[19];
     *p = '\0';
     do {
 	*--p = ((int)(n%10)) + '0';
 	n /= 10;
     } while ( n );
     store( p, qstrlen(p)+1 );
     return *this;
 }
 
 /*!
     \overload QCString &QCString::setNum( int n )
 
     Sets the string to the string representation of the number \a n
     and returns a reference to the string.
 */
 
 /*!
     \overload QCString &QCString::setNum( uint n )
 
     Sets the string to the string representation of the number \a n
     and returns a reference to the string.
 */
 
 /*!
     \overload QCString &QCString::setNum( short n )
 
     Sets the string to the string representation of the number \a n
     and returns a reference to the string.
 */
 
 /*!
     \overload QCString &QCString::setNum( ushort n )
 
     Sets the string to the string representation of the number \a n
     and returns a reference to the string.
 */
 
 /*!
     Sets the string to the string representation of the number \a n
     and returns a reference to the string.
 
     The format of the string representation is specified by the format
     character \a f, and the precision (number of digits after the
     decimal point) is specified with \a prec.
 
     The valid formats for \a f are 'e', 'E', 'f', 'g' and 'G'. The
     formats are the same as for sprintf(); they are explained in \l
     QString::arg().
 */
 
 QCString &QCString::setNum( double n, char f, int prec )
 {
 #if defined(QT_CHECK_RANGE)
     if ( !(f=='f' || f=='F' || f=='e' || f=='E' || f=='g' || f=='G') )
 	qWarning( "QCString::setNum: Invalid format char '%c'", f );
 #endif
     char format[20];
     register char *fs = format;			// generate format string
     *fs++ = '%';				//   "%.<prec>l<f>"
     if ( prec > 99 )
 	prec = 99;
     *fs++ = '.';
     if ( prec >= 10 ) {
 	*fs++ = prec / 10 + '0';
 	*fs++ = prec % 10 + '0';
     } else {
 	*fs++ = prec + '0';
     }
     *fs++ = 'l';
     *fs++ = f;
     *fs = '\0';
     return sprintf( format, n );
 }
 
 /*! \overload QCString &QCString::setNum( float n, char f, int prec ) */
 
 
 /*!
     Sets the character at position \a index to \a c and expands the
     string if necessary, padding with spaces.
 
     Returns FALSE if \a index was out of range and the string could
     not be expanded; otherwise returns TRUE.
 */
 
 bool QCString::setExpand( uint index, char c )
 {
     detach();
     uint oldlen = length();
     if ( index >= oldlen ) {
 	if ( !QByteArray::resize( index+2 ) )	// no memory
 	    return FALSE;
 	if ( index > oldlen )
 	    memset( data() + oldlen, ' ', index - oldlen );
 	*(data() + index+1) = '\0';		// terminate padded string
     }
     *(data() + index) = c;
     return TRUE;
 }
 
 
 /*!
     \fn QCString::operator const char *() const
 
     Returns the string data.
 */
 
 
 /*!
     \fn QCString& QCString::append( const char *str )
 
     Appends string \a str to the string and returns a reference to the
     string. Equivalent to operator+=().
 */
 
 /*!
     Appends string \a str to the string and returns a reference to the string.
 */
 
 QCString& QCString::operator+=( const char *str )
 {
     if ( !str )
 	return *this;				// nothing to append
     detach();
     uint len1 = length();
     uint len2 = qstrlen(str);
-    if ( !QByteArray::resize( len1 + len2 + 1 ) )
+    if ( !QByteArray::resize( len1 + len2 + 1, QByteArray::SpeedOptim ) )
 	return *this;				// no memory
     memcpy( data() + len1, str, len2 + 1 );
     return *this;
 }
 
 /*!
     \overload
 
     Appends character \a c to the string and returns a reference to the string.
 */
 
 QCString &QCString::operator+=( char c )
 {
     detach();
     uint len = length();
-    if ( !QByteArray::resize( len + 2 ) )
+    if ( !QByteArray::resize( len + 2, QByteArray::SpeedOptim  ) )
 	return *this;				// no memory
     *(data() + len) = c;
     *(data() + len+1) = '\0';
     return *this;
 }
 
 
 /*****************************************************************************
   QCString stream functions
  *****************************************************************************/
 #ifndef QT_NO_DATASTREAM
 /*!
     \relates QCString
 
     Writes string \a str to the stream \a s.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 QDataStream &operator<<( QDataStream &s, const QCString &str )
 {
     return s.writeBytes( str.data(), str.size() );
 }
 
 /*!
     \relates QCString
 
     Reads a string into \a str from the stream \a s.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator>>( QDataStream &s, QCString &str )
 {
     str.detach();
     Q_UINT32 len;
     s >> len;					// read size of string
     if ( len == 0 || s.eof() ) {		// end of file reached
 	str.resize( 0 );
 	return s;
     }
     if ( !str.QByteArray::resize( (uint)len )) {// resize string
 #if defined(QT_CHECK_NULL)
 	qWarning( "QDataStream: Not enough memory to read QCString" );
 #endif
 	len = 0;
     }
     if ( len > 0 )				// not null array
 	s.readRawBytes( str.data(), (uint)len );
     return s;
 }
 #endif //QT_NO_DATASTREAM
 
 /*****************************************************************************
   Documentation for related functions
  *****************************************************************************/
 
 /*!
     \fn bool operator==( const QCString &s1, const QCString &s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 and \a s2 are equal; otherwise returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) == 0.
 */
 
 /*!
     \overload bool operator==( const QCString &s1, const char *s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 and \a s2 are equal; otherwise returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) == 0.
 */
 
 /*!
     \overload bool operator==( const char *s1, const QCString &s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 and \a s2 are equal; otherwise returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) == 0.
 */
 
 /*!
     \fn bool operator!=( const QCString &s1, const QCString &s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 and \a s2 are different; otherwise returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) != 0.
 */
 
 /*!
     \overload bool operator!=( const QCString &s1, const char *s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 and \a s2 are different; otherwise returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) != 0.
 */
 
 /*!
     \overload bool operator!=( const char *s1, const QCString &s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 and \a s2 are different; otherwise returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) != 0.
 */
 
 /*!
     \fn bool operator<( const QCString &s1, const char *s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 is less than \a s2; otherwise returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) \< 0.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 /*!
     \overload bool operator<( const char *s1, const QCString &s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 is less than \a s2; otherwise returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) \< 0.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 /*!
     \fn bool operator<=( const QCString &s1, const char *s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 is less than or equal to \a s2; otherwise
     returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) \<= 0.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 /*!
     \overload bool operator<=( const char *s1, const QCString &s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 is less than or equal to \a s2; otherwise
     returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) \<= 0.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 /*!
     \fn bool operator>( const QCString &s1, const char *s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 is greater than \a s2; otherwise returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) \> 0.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 /*!
     \overload bool operator>( const char *s1, const QCString &s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 is greater than \a s2; otherwise returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) \> 0.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 /*!
     \fn bool operator>=( const QCString &s1, const char *s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 is greater than or equal to \a s2; otherwise
     returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) \>= 0.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 /*!
     \overload bool operator>=( const char *s1, const QCString &s2 )
 
     \relates QCString
 
     Returns TRUE if \a s1 is greater than or equal to \a s2; otherwise
     returns FALSE.
 
     Equivalent to qstrcmp(\a s1, \a s2) \>= 0.
 
     \sa \link #asciinotion Note on character comparisons \endlink
 */
 
 /*!
     \fn const QCString operator+( const QCString &s1, const QCString &s2 )
 
     \relates QCString
 
     Returns a string which consists of the concatenation of \a s1 and
     \a s2.
 */
 
 /*!
     \overload const QCString operator+( const QCString &s1, const char *s2 )
 
     \relates QCString
 
     Returns a string which consists of the concatenation of \a s1 and \a s2.
 */
 
 /*!
     \overload const QCString operator+( const char *s1, const QCString &s2 )
 
     \relates QCString
 
     Returns a string which consists of the concatenation of \a s1 and \a s2.
 */
 
 /*!
     \overload const QCString operator+( const QCString &s, char c )
 
     \relates QCString
 
     Returns a string which consists of the concatenation of \a s and \a c.
 */
 
 /*!
     \overload const QCString operator+( char c, const QCString &s )
 
     \relates QCString
 
     Returns a string which consists of the concatenation of \a c and \a s.
 */
diff --git a/qmake/tools/qdatastream.cpp b/qmake/tools/qdatastream.cpp
index 9c573c7..51a1448 100644
--- a/qmake/tools/qdatastream.cpp
+++ b/qmake/tools/qdatastream.cpp
@@ -1,1024 +1,1038 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QDataStream class
 **
 ** Created : 930831
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qdatastream.h"
 
 #ifndef QT_NO_DATASTREAM
 #include "qbuffer.h"
 #include <stdio.h>
 #include <ctype.h>
 #include <stdlib.h>
 
 /*!
     \class QDataStream qdatastream.h
     \reentrant
     \brief The QDataStream class provides serialization of binary data
     to a QIODevice.
 
     \ingroup io
 
     A data stream is a binary stream of encoded information which is
     100% independent of the host computer's operating system, CPU or
     byte order. For example, a data stream that is written by a PC
     under Windows can be read by a Sun SPARC running Solaris.
 
     You can also use a data stream to read/write \link #raw raw
     unencoded binary data\endlink. If you want a "parsing" input
     stream, see QTextStream.
 
     The QDataStream class implements serialization of primitive types,
     like \c char, \c short, \c int, \c char* etc. Serialization of
     more complex data is accomplished by breaking up the data into
     primitive units.
 
     A data stream cooperates closely with a QIODevice. A QIODevice
     represents an input/output medium one can read data from and write
     data to. The QFile class is an example of an IO device.
 
     Example (write binary data to a stream):
     \code
     QFile file( "file.dat" );
     file.open( IO_WriteOnly );
     QDataStream stream( &file ); // we will serialize the data into the file
     stream << "the answer is";   // serialize a string
     stream << (Q_INT32)42;       // serialize an integer
     \endcode
 
     Example (read binary data from a stream):
     \code
     QFile file( "file.dat" );
     file.open( IO_ReadOnly );
     QDataStream stream( &file );  // read the data serialized from the file
     QString str;
     Q_INT32 a;
     stream >> str >> a;           // extract "the answer is" and 42
     \endcode
 
     Each item written to the stream is written in a predefined binary
     format that varies depending on the item's type. Supported Qt
     types include QBrush, QColor, QDateTime, QFont, QPixmap, QString,
     QVariant and many others. For the complete list of all Qt types
     supporting data streaming see the \link datastreamformat.html
     Format of the QDataStream operators \endlink.
 
     To take one example, a \c char* string is written as a 32-bit
     integer equal to the length of the string including the NUL byte
     ('\0'), followed by all the characters of the string including the
     NUL byte. When reading a \c char* string, 4 bytes are read to
     create the 32-bit length value, then that many characters for the
     \c char* string including the NUL are read.
 
     The initial IODevice is usually set in the constructor, but can be
     changed with setDevice(). If you've reached the end of the data
     (or if there is no IODevice set) atEnd() will return TRUE.
 
     If you want the data to be compatible with an earlier version of
     Qt use setVersion().
 
     If you want the data to be human-readable, e.g. for debugging, you
     can set the data stream into printable data mode with
     setPrintableData(). The data is then written slower, in a bloated
     but human readable format.
 
     If you are producing a new binary data format, such as a file
     format for documents created by your application, you could use a
     QDataStream to write the data in a portable format. Typically, you
     would write a brief header containing a magic string and a version
     number to give yourself room for future expansion. For example:
 
     \code
     QFile file( "file.xxx" );
     file.open( IO_WriteOnly );
     QDataStream stream( &file );
 
     // Write a header with a "magic number" and a version
     stream << (Q_UINT32)0xA0B0C0D0;
     stream << (Q_INT32)123;
 
     // Write the data
     stream << [lots of interesting data]
     \endcode
 
     Then read it in with:
 
     \code
     QFile file( "file.xxx" );
     file.open( IO_ReadOnly );
     QDataStream stream( &file );
 
     // Read and check the header
     Q_UINT32 magic;
     stream >> magic;
     if ( magic != 0xA0B0C0D0 )
 	return XXX_BAD_FILE_FORMAT;
 
     // Read the version
     Q_INT32 version;
     stream >> version;
     if ( version < 100 )
 	return XXX_BAD_FILE_TOO_OLD;
     if ( version > 123 )
 	return XXX_BAD_FILE_TOO_NEW;
     if ( version <= 110 )
 	stream.setVersion(1);
 
     // Read the data
     stream >> [lots of interesting data];
     if ( version > 120 )
 	stream >> [data new in XXX version 1.2];
     stream >> [other interesting data];
     \endcode
 
     You can select which byte order to use when serializing data. The
     default setting is big endian (MSB first). Changing it to little
     endian breaks the portability (unless the reader also changes to
     little endian). We recommend keeping this setting unless you have
     special requirements.
 
     \target raw
     \section1 Reading and writing raw binary data
 
     You may wish to read/write your own raw binary data to/from the
     data stream directly. Data may be read from the stream into a
     preallocated char* using readRawBytes(). Similarly data can be
     written to the stream using writeRawBytes(). Notice that any
     encoding/decoding of the data must be done by you.
 
     A similar pair of functions is readBytes() and writeBytes(). These
     differ from their \e raw counterparts as follows: readBytes()
     reads a Q_UINT32 which is taken to be the length of the data to be
     read, then that number of bytes is read into the preallocated
     char*; writeBytes() writes a Q_UINT32 containing the length of the
     data, followed by the data. Notice that any encoding/decoding of
     the data (apart from the length Q_UINT32) must be done by you.
 
     \sa QTextStream QVariant
 */
 
 /*!
     \enum QDataStream::ByteOrder
 
     The byte order used for reading/writing the data.
 
     \value BigEndian the default
     \value LittleEndian
 */
 
 
 /*****************************************************************************
   QDataStream member functions
  *****************************************************************************/
 
 #if defined(QT_CHECK_STATE)
 #undef  CHECK_STREAM_PRECOND
 #define CHECK_STREAM_PRECOND  if ( !dev ) {				\
 				qWarning( "QDataStream: No device" );	\
 				return *this; }
 #else
 #define CHECK_STREAM_PRECOND
 #endif
 
 static int  systemWordSize = 0;
 static bool systemBigEndian;
 
 static const int DefaultStreamVersion = 5;
 // 5 is default in Qt 3.1
 // 4 is default in Qt 3.0
 // 3 is default in Qt 2.1
 // 2 is the Qt 2.0.x format
 // 1 is the Qt 1.x format
 
 /*!
     Constructs a data stream that has no IO device.
 
     \sa setDevice()
 */
 
 QDataStream::QDataStream()
 {
     if ( systemWordSize == 0 )			// get system features
 	qSysInfo( &systemWordSize, &systemBigEndian );
     dev	      = 0;				// no device set
     owndev    = FALSE;
     byteorder = BigEndian;			// default byte order
     printable = FALSE;
     ver	      = DefaultStreamVersion;
     noswap    = systemBigEndian;
 }
 
 /*!
     Constructs a data stream that uses the IO device \a d.
 
     \warning If you use QSocket or QSocketDevice as the IO device \a d
     for reading data, you must make sure that enough data is available
     on the socket for the operation to successfully proceed;
     QDataStream does not have any means to handle or recover from
     short-reads.
 
     \sa setDevice(), device()
 */
 
 QDataStream::QDataStream( QIODevice *d )
 {
     if ( systemWordSize == 0 )			// get system features
 	qSysInfo( &systemWordSize, &systemBigEndian );
     dev	      = d;				// set device
     owndev    = FALSE;
     byteorder = BigEndian;			// default byte order
     printable = FALSE;
     ver	      = DefaultStreamVersion;
     noswap    = systemBigEndian;
 }
 
 /*!
     Constructs a data stream that operates on a byte array, \a a,
     through an internal QBuffer device. The \a mode is a
     QIODevice::mode(), usually either \c IO_ReadOnly or \c
     IO_WriteOnly.
 
     Example:
     \code
     static char bindata[] = { 231, 1, 44, ... };
     QByteArray a;
     a.setRawData( bindata, sizeof(bindata) );	// a points to bindata
     QDataStream stream( a, IO_ReadOnly );	// open on a's data
     stream >> [something];			// read raw bindata
     a.resetRawData( bindata, sizeof(bindata) ); // finished
     \endcode
 
     The QByteArray::setRawData() function is not for the inexperienced.
 */
 
 QDataStream::QDataStream( QByteArray a, int mode )
 {
     if ( systemWordSize == 0 )			// get system features
 	qSysInfo( &systemWordSize, &systemBigEndian );
     dev	      = new QBuffer( a );		// create device
     ((QBuffer *)dev)->open( mode );		// open device
     owndev    = TRUE;
     byteorder = BigEndian;			// default byte order
     printable = FALSE;
     ver	      = DefaultStreamVersion;
     noswap    = systemBigEndian;
 }
 
 /*!
     Destroys the data stream.
 
     The destructor will not affect the current IO device, unless it is
     an internal IO device processing a QByteArray passed in the \e
     constructor, in which case the internal IO device is destroyed.
 */
 
 QDataStream::~QDataStream()
 {
     if ( owndev )
 	delete dev;
 }
 
 
 /*!
     \fn QIODevice *QDataStream::device() const
 
     Returns the IO device currently set.
 
     \sa setDevice(), unsetDevice()
 */
 
 /*!
     void QDataStream::setDevice(QIODevice *d )
 
     Sets the IO device to \a d.
 
     \sa device(), unsetDevice()
 */
 
 void QDataStream::setDevice(QIODevice *d )
 {
     if ( owndev ) {
 	delete dev;
 	owndev = FALSE;
     }
     dev = d;
 }
 
 /*!
     Unsets the IO device. This is the same as calling setDevice( 0 ).
 
     \sa device(), setDevice()
 */
 
 void QDataStream::unsetDevice()
 {
     setDevice( 0 );
 }
 
 
 /*!
     \fn bool QDataStream::atEnd() const
 
     Returns TRUE if the IO device has reached the end position (end of
     the stream or file) or if there is no IO device set; otherwise
     returns FALSE, i.e. if the current position of the IO device is
     before the end position.
 
     \sa QIODevice::atEnd()
 */
 
 /*!\fn bool QDataStream::eof() const
 
   \obsolete
 
   Returns TRUE if the IO device has reached the end position (end of
   stream or file) or if there is no IO device set.
 
   Returns FALSE if the current position of the read/write head of the IO
   device is somewhere before the end position.
 
   \sa QIODevice::atEnd()
 */
 
 /*!
     \fn int QDataStream::byteOrder() const
 
     Returns the current byte order setting -- either \c BigEndian or
     \c LittleEndian.
 
     \sa setByteOrder()
 */
 
 /*!
     Sets the serialization byte order to \a bo.
 
     The \a bo parameter can be \c QDataStream::BigEndian or \c
     QDataStream::LittleEndian.
 
     The default setting is big endian. We recommend leaving this
     setting unless you have special requirements.
 
     \sa byteOrder()
 */
 
 void QDataStream::setByteOrder( int bo )
 {
     byteorder = bo;
     if ( systemBigEndian )
 	noswap = byteorder == BigEndian;
     else
 	noswap = byteorder == LittleEndian;
 }
 
 
 /*!
     \fn bool QDataStream::isPrintableData() const
 
     Returns TRUE if the printable data flag has been set; otherwise
     returns FALSE.
 
     \sa setPrintableData()
 */
 
 /*!
     \fn void QDataStream::setPrintableData( bool enable )
 
     If \a enable is TRUE, data will be output in a human readable
     format. If \a enable is FALSE, data will be output in a binary
     format.
 
     If \a enable is TRUE, the write functions will generate output
     that consists of printable characters (7 bit ASCII). This output
     will typically be a lot larger than the default binary output, and
     consequently slower to write.
 
     We recommend only enabling printable data for debugging purposes.
 */
 
 
 /*!
     \fn int QDataStream::version() const
 
     Returns the version number of the data serialization format. In Qt
     3.1, this number is 5.
 
     \sa setVersion()
 */
 
 /*!
     \fn void QDataStream::setVersion( int v )
 
     Sets the version number of the data serialization format to \a v.
 
     You don't need to set a version if you are using the current
     version of Qt.
 
     In order to accommodate new functionality, the datastream
     serialization format of some Qt classes has changed in some
     versions of Qt. If you want to read data that was created by an
     earlier version of Qt, or write data that can be read by a program
     that was compiled with an earlier version of Qt, use this function
     to modify the serialization format of QDataStream.
 
     \table
     \header \i Qt Version	    \i QDataStream Version
     \row \i Qt 3.1		    \i11 5
     \row \i Qt 3.0		    \i11 4
     \row \i Qt 2.1.x and Qt 2.2.x   \i11 3
     \row \i Qt 2.0.x		    \i11 2
     \row \i Qt 1.x		    \i11 1
     \endtable
 
     \sa version()
 */
 
 /*****************************************************************************
   QDataStream read functions
  *****************************************************************************/
 
 
 static Q_INT32 read_int_ascii( QDataStream *s )
 {
     register int n = 0;
     char buf[40];
     for ( ;; ) {
 	buf[n] = s->device()->getch();
 	if ( buf[n] == '\n' || n > 38 )		// $-terminator
 	    break;
 	n++;
     }
     buf[n] = '\0';
     return atol( buf );
 }
 
 
 /*!
     \overload QDataStream &QDataStream::operator>>( Q_UINT8 &i )
 
     Reads an unsigned byte from the stream into \a i, and returns a
     reference to the stream.
 */
 
 /*!
     Reads a signed byte from the stream into \a i, and returns a
     reference to the stream.
 */
 
 QDataStream &QDataStream::operator>>( Q_INT8 &i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	i = (Q_INT8)dev->getch();
 	if ( i == '\\' ) {			// read octal code
 	    char buf[4];
 	    dev->readBlock( buf, 3 );
 	    i = (buf[2] & 0x07)+((buf[1] & 0x07) << 3)+((buf[0] & 0x07) << 6);
 	}
     } else {					// data or text
 	i = (Q_INT8)dev->getch();
     }
     return *this;
 }
 
 
 /*!
     \overload QDataStream &QDataStream::operator>>( Q_UINT16 &i )
 
     Reads an unsigned 16-bit integer from the stream into \a i, and
     returns a reference to the stream.
 */
 
 /*!
     \overload
 
     Reads a signed 16-bit integer from the stream into \a i, and
     returns a reference to the stream.
 */
 
 QDataStream &QDataStream::operator>>( Q_INT16 &i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	i = (Q_INT16)read_int_ascii( this );
     } else if ( noswap ) {			// no conversion needed
 	dev->readBlock( (char *)&i, sizeof(Q_INT16) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
 	char b[2];
 	dev->readBlock( b, 2 );
 	*p++ = b[1];
 	*p   = b[0];
     }
     return *this;
 }
 
 
 /*!
     \overload QDataStream &QDataStream::operator>>( Q_UINT32 &i )
 
     Reads an unsigned 32-bit integer from the stream into \a i, and
     returns a reference to the stream.
 */
 
 /*!
     \overload
 
     Reads a signed 32-bit integer from the stream into \a i, and
     returns a reference to the stream.
 */
 
 QDataStream &QDataStream::operator>>( Q_INT32 &i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	i = read_int_ascii( this );
     } else if ( noswap ) {			// no conversion needed
 	dev->readBlock( (char *)&i, sizeof(Q_INT32) );
     } else {					// swap bytes
 	uchar *p = (uchar *)(&i);
 	char b[4];
 	dev->readBlock( b, 4 );
 	*p++ = b[3];
 	*p++ = b[2];
 	*p++ = b[1];
 	*p   = b[0];
     }
     return *this;
 }
 
 /*!
     \overload QDataStream &QDataStream::operator>>( Q_ULONG &i )
 
     Reads an unsigned integer of the system's word length from the
     stream, into \a i, and returns a reference to the stream.
 */
 
 /*!
     \overload
 
     Reads a signed integer of the system's word length from the stream
     into \a i, and returns a reference to the stream.
 */
 
 QDataStream &QDataStream::operator>>( Q_LONG &i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	i = read_int_ascii( this );
     } else if ( noswap ) {			// no conversion needed
 	dev->readBlock( (char *)&i, sizeof(Q_LONG) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
 	char b[sizeof(Q_LONG)];
 	dev->readBlock( b, sizeof(Q_LONG) );
 	for ( int j = sizeof(Q_LONG); j;  )
 	    *p++ = b[--j];
     }
     return *this;
 }
 
 static double read_double_ascii( QDataStream *s )
 {
     register int n = 0;
     char buf[80];
     for ( ;; ) {
 	buf[n] = s->device()->getch();
 	if ( buf[n] == '\n' || n > 78 )		// $-terminator
 	    break;
 	n++;
     }
     buf[n] = '\0';
     return atof( buf );
 }
 
 
 /*!
     \overload
 
     Reads a 32-bit floating point number from the stream into \a f,
     using the standard IEEE754 format. Returns a reference to the
     stream.
 */
 
 QDataStream &QDataStream::operator>>( float &f )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	f = (float)read_double_ascii( this );
     } else if ( noswap ) {			// no conversion needed
 	dev->readBlock( (char *)&f, sizeof(float) );
     } else {					// swap bytes
 	uchar *p = (uchar *)(&f);
 	char b[4];
 	dev->readBlock( b, 4 );
 	*p++ = b[3];
 	*p++ = b[2];
 	*p++ = b[1];
 	*p   = b[0];
     }
     return *this;
 }
 
 
 /*!
     \overload
 
     Reads a 64-bit floating point number from the stream into \a f,
     using the standard IEEE754 format. Returns a reference to the
     stream.
 */
 
 QDataStream &QDataStream::operator>>( double &f )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	f = read_double_ascii( this );
     } else if ( noswap ) {			// no conversion needed
 	dev->readBlock( (char *)&f, sizeof(double) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&f);
 	char b[8];
 	dev->readBlock( b, 8 );
 	*p++ = b[7];
 	*p++ = b[6];
 	*p++ = b[5];
 	*p++ = b[4];
 	*p++ = b[3];
 	*p++ = b[2];
 	*p++ = b[1];
 	*p   = b[0];
     }
     return *this;
 }
 
 
 /*!
     \overload
 
     Reads the '\0'-terminated string \a s from the stream and returns
     a reference to the stream.
 
     Space for the string is allocated using \c new -- the caller must
     destroy it with delete[].
 */
 
 QDataStream &QDataStream::operator>>( char *&s )
 {
     uint len = 0;
     return readBytes( s, len );
 }
 
 
 /*!
     Reads the buffer \a s from the stream and returns a reference to
     the stream.
 
     The buffer \a s is allocated using \c new. Destroy it with the \c
     delete[] operator. If the length is zero or \a s cannot be
     allocated, \a s is set to 0.
 
     The \a l parameter will be set to the length of the buffer.
 
     The serialization format is a Q_UINT32 length specifier first,
     then \a l bytes of data. Note that the data is \e not encoded.
 
     \sa readRawBytes(), writeBytes()
 */
 
 QDataStream &QDataStream::readBytes( char *&s, uint &l )
 {
     CHECK_STREAM_PRECOND
     Q_UINT32 len;
     *this >> len;				// first read length spec
     l = (uint)len;
     if ( len == 0 || eof() ) {
 	s = 0;
 	return *this;
     } else {
 	s = new char[len];			// create char array
 	Q_CHECK_PTR( s );
 	if ( !s )				// no memory
 	    return *this;
 	return readRawBytes( s, (uint)len );
     }
 }
 
 
 /*!
     Reads \a len bytes from the stream into \a s and returns a
     reference to the stream.
 
     The buffer \a s must be preallocated. The data is \e not encoded.
 
     \sa readBytes(), QIODevice::readBlock(), writeRawBytes()
 */
 
 QDataStream &QDataStream::readRawBytes( char *s, uint len )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	register Q_INT8 *p = (Q_INT8*)s;
-	while ( len-- )
-	    *this >> *p++;
+	if ( version() < 4 ) {
+	    while ( len-- ) {
+		Q_INT32 tmp;
+		*this >> tmp;
+		*p++ = tmp;
+	    }
+	} else {
+	    while ( len-- )
+		*this >> *p++;
+	}
     } else {					// read data char array
 	dev->readBlock( s, len );
     }
     return *this;
 }
 
 
 /*****************************************************************************
   QDataStream write functions
  *****************************************************************************/
 
 
 /*!
     \overload QDataStream &QDataStream::operator<<( Q_UINT8 i )
 
     Writes an unsigned byte, \a i, to the stream and returns a
     reference to the stream.
 */
 
 /*!
     Writes a signed byte, \a i, to the stream and returns a reference
     to the stream.
 */
 
 QDataStream &QDataStream::operator<<( Q_INT8 i )
 {
     CHECK_STREAM_PRECOND
     if ( printable && (i == '\\' || !isprint((uchar) i)) ) {
 	char buf[6];				// write octal code
 	buf[0] = '\\';
 	buf[1] = '0' + ((i >> 6) & 0x07);
 	buf[2] = '0' + ((i >> 3) & 0x07);
 	buf[3] = '0' + (i & 0x07);
 	buf[4] = '\0';
 	dev->writeBlock( buf, 4 );
     } else {
 	dev->putch( i );
     }
     return *this;
 }
 
 
 /*!
     \overload QDataStream &QDataStream::operator<<( Q_UINT16 i )
 
     Writes an unsigned 16-bit integer, \a i, to the stream and returns
     a reference to the stream.
 */
 
 /*!
     \overload
 
     Writes a signed 16-bit integer, \a i, to the stream and returns a
     reference to the stream.
 */
 
 QDataStream &QDataStream::operator<<( Q_INT16 i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	char buf[16];
 	sprintf( buf, "%d\n", i );
 	dev->writeBlock( buf, strlen(buf) );
     } else if ( noswap ) {			// no conversion needed
 	dev->writeBlock( (char *)&i, sizeof(Q_INT16) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
 	char b[2];
 	b[1] = *p++;
 	b[0] = *p;
 	dev->writeBlock( b, 2 );
     }
     return *this;
 }
 
 /*!
     \overload
 
     Writes a signed 32-bit integer, \a i, to the stream and returns a
     reference to the stream.
 */
 
 QDataStream &QDataStream::operator<<( Q_INT32 i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	char buf[16];
 	sprintf( buf, "%d\n", i );
 	dev->writeBlock( buf, strlen(buf) );
     } else if ( noswap ) {			// no conversion needed
 	dev->writeBlock( (char *)&i, sizeof(Q_INT32) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
 	char b[4];
 	b[3] = *p++;
 	b[2] = *p++;
 	b[1] = *p++;
 	b[0] = *p;
 	dev->writeBlock( b, 4 );
     }
     return *this;
 }
 
 /*!
     \overload QDataStream &QDataStream::operator<<( Q_ULONG i )
 
     Writes an unsigned integer \a i, of the system's word length, to
     the stream and returns a reference to the stream.
 */
 
 /*!
     \overload
 
     Writes a signed integer \a i, of the system's word length, to the
     stream and returns a reference to the stream.
 */
 
 QDataStream &QDataStream::operator<<( Q_LONG i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	char buf[20];
 	sprintf( buf, "%ld\n", i );
 	dev->writeBlock( buf, strlen(buf) );
     } else if ( noswap ) {			// no conversion needed
 	dev->writeBlock( (char *)&i, sizeof(Q_LONG) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
 	char b[sizeof(Q_LONG)];
 	for ( int j = sizeof(Q_LONG); j;  )
 	    b[--j] = *p++;
 	dev->writeBlock( b, sizeof(Q_LONG) );
     }
     return *this;
 }
 
 /*!
     \overload QDataStream &QDataStream::operator<<( Q_UINT32 i )
 
     Writes an unsigned integer, \a i, to the stream as a 32-bit
     unsigned integer (Q_UINT32). Returns a reference to the stream.
 */
 
 /*!
     \overload
 
     Writes a 32-bit floating point number, \a f, to the stream using
     the standard IEEE754 format. Returns a reference to the stream.
 */
 
 QDataStream &QDataStream::operator<<( float f )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	char buf[32];
 	sprintf( buf, "%g\n", (double)f );
 	dev->writeBlock( buf, strlen(buf) );
     } else {
 	float g = f;				// fixes float-on-stack problem
 	if ( noswap ) {				// no conversion needed
 	    dev->writeBlock( (char *)&g, sizeof(float) );
 	} else {				// swap bytes
 	    register uchar *p = (uchar *)(&g);
 	    char b[4];
 	    b[3] = *p++;
 	    b[2] = *p++;
 	    b[1] = *p++;
 	    b[0] = *p;
 	    dev->writeBlock( b, 4 );
 	}
     }
     return *this;
 }
 
 
 /*!
     \overload
 
     Writes a 64-bit floating point number, \a f, to the stream using
     the standard IEEE754 format. Returns a reference to the stream.
 */
 
 QDataStream &QDataStream::operator<<( double f )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	char buf[32];
 	sprintf( buf, "%g\n", f );
 	dev->writeBlock( buf, strlen(buf) );
     } else if ( noswap ) {			// no conversion needed
 	dev->writeBlock( (char *)&f, sizeof(double) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&f);
 	char b[8];
 	b[7] = *p++;
 	b[6] = *p++;
 	b[5] = *p++;
 	b[4] = *p++;
 	b[3] = *p++;
 	b[2] = *p++;
 	b[1] = *p++;
 	b[0] = *p;
 	dev->writeBlock( b, 8 );
     }
     return *this;
 }
 
 
 /*!
     \overload
 
     Writes the '\0'-terminated string \a s to the stream and returns a
     reference to the stream.
 
     The string is serialized using writeBytes().
 */
 
 QDataStream &QDataStream::operator<<( const char *s )
 {
     if ( !s ) {
 	*this << (Q_UINT32)0;
 	return *this;
     }
     uint len = qstrlen( s ) + 1;			// also write null terminator
     *this << (Q_UINT32)len;			// write length specifier
     return writeRawBytes( s, len );
 }
 
 
 /*!
     Writes the length specifier \a len and the buffer \a s to the
     stream and returns a reference to the stream.
 
     The \a len is serialized as a Q_UINT32, followed by \a len bytes
     from \a s. Note that the data is \e not encoded.
 
     \sa writeRawBytes(), readBytes()
 */
 
 QDataStream &QDataStream::writeBytes(const char *s, uint len)
 {
     CHECK_STREAM_PRECOND
     *this << (Q_UINT32)len;			// write length specifier
     if ( len )
 	writeRawBytes( s, len );
     return *this;
 }
 
 
 /*!
     Writes \a len bytes from \a s to the stream and returns a
     reference to the stream. The data is \e not encoded.
 
     \sa writeBytes(), QIODevice::writeBlock(), readRawBytes()
 */
 
 QDataStream &QDataStream::writeRawBytes( const char *s, uint len )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// write printable
-	register Q_INT8 *p = (Q_INT8*)s;
-	while ( len-- )
-	    *this << *p++;
+	if ( version() < 4 ) {
+	    register char *p = (char *)s;
+	    while ( len-- )
+		*this << *p++;
+	} else {
+	    register Q_INT8 *p = (Q_INT8*)s;
+	    while ( len-- )
+		*this << *p++;
+	}
     } else {					// write data char array
 	dev->writeBlock( s, len );
     }
     return *this;
 }
 
 #endif // QT_NO_DATASTREAM
diff --git a/qmake/tools/qdatetime.cpp b/qmake/tools/qdatetime.cpp
index 93e40a8..3137877 100644
--- a/qmake/tools/qdatetime.cpp
+++ b/qmake/tools/qdatetime.cpp
@@ -1,2490 +1,2536 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of date and time classes
 **
 ** Created : 940124
 **
-** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
-// Get the system specific includes and defines
 #include "qplatformdefs.h"
 
 #include "qdatetime.h"
 #include "qdatastream.h"
 #include "qregexp.h"
 
 #include <stdio.h>
 #ifndef Q_OS_TEMP
 #include <time.h>
 #endif
 
 #if defined(Q_OS_WIN32)
 #include <windows.h>
 #endif
 
 static const uint FIRST_DAY	= 2361222;	// Julian day for 1752-09-14
 static const int  FIRST_YEAR	= 1752;		// ### wrong for many countries
 static const uint SECS_PER_DAY	= 86400;
 static const uint MSECS_PER_DAY = 86400000;
 static const uint SECS_PER_HOUR = 3600;
 static const uint MSECS_PER_HOUR= 3600000;
 static const uint SECS_PER_MIN	= 60;
 static const uint MSECS_PER_MIN = 60000;
 
 static const short monthDays[] = {
     0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
 static const char * const qt_shortMonthNames[] = {
 	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
 	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
 
 #ifndef QT_NO_DATESTRING
 /*****************************************************************************
   Some static function used by QDate, QTime and QDateTime
  *****************************************************************************/
 
 // Replaces tokens by their value. See QDateTime::toString() for a list of valid tokens
 static QString getFmtString( const QString& f, const QTime* dt = 0, const QDate* dd = 0, bool am_pm = FALSE )
 {
     if ( f.isEmpty() )
 	return QString::null;
 
     QString buf = f;
 
     if ( dt ) {
 	if ( f == "h" ) {
 	    if ( ( am_pm ) && ( dt->hour() > 12 ) )
 		buf = QString::number( dt->hour() - 12 );
 	    else if ( ( am_pm ) && ( dt->hour() == 0 ) )
 		buf = "12";
 	    else
 		buf = QString::number( dt->hour() );
 	} else if ( f == "hh" ) {
 	    if ( ( am_pm ) && ( dt->hour() > 12 ) )
 		buf = QString::number( dt->hour() - 12 ).rightJustify( 2, '0', TRUE );
 	    else if ( ( am_pm ) && ( dt->hour() == 0 ) )
 		buf = "12";
 	    else
 		buf = QString::number( dt->hour() ).rightJustify( 2, '0', TRUE );
 	} else if ( f == "m" ) {
 	    buf = QString::number( dt->minute() );
 	} else if ( f == "mm" ) {
 	    buf = QString::number( dt->minute() ).rightJustify( 2, '0', TRUE );
 	} else if ( f == "s" ) {
 	    buf = QString::number( dt->second() );
 	} else if ( f == "ss" ) {
 	    buf = QString::number( dt->second() ).rightJustify( 2, '0', TRUE );
 	} else if ( f == "z" ) {
 	    buf = QString::number( dt->msec() );
 	} else if ( f == "zzz" ) {
 	    buf = QString::number( dt->msec() ).rightJustify( 3, '0', TRUE );
 	} else if ( f == "ap" ) {
 	    buf = dt->hour() < 12 ? "am" : "pm";
 	} else if ( f == "AP" ) {
 	    buf = dt->hour() < 12 ? "AM" : "PM";
 	}
     }
 
     if ( dd ) {
 	if ( f == "d" ) {
 	    buf = QString::number( dd->day() );
 	} else if ( f == "dd" ) {
 	    buf = QString::number( dd->day() ).rightJustify( 2, '0', TRUE );
 	} else if ( f == "M" ) {
 	    buf = QString::number( dd->month() );
 	} else if ( f == "MM" ) {
 	    buf = QString::number( dd->month() ).rightJustify( 2, '0', TRUE );
 #ifndef QT_NO_TEXTDATE
 	} else if ( f == "ddd" ) {
 	    buf = dd->shortDayName( dd->dayOfWeek() );
 	} else if ( f == "dddd" ) {
 	    buf = dd->longDayName( dd->dayOfWeek() );
 	} else if ( f == "MMM" ) {
 	    buf = dd->shortMonthName( dd->month() );
 	} else if ( f == "MMMM" ) {
 	    buf = dd->longMonthName( dd->month() );
 #endif
 	} else if ( f == "yy" ) {
 	    buf = QString::number( dd->year() ).right( 2 );
 	} else if ( f == "yyyy" ) {
 	    buf = QString::number( dd->year() );
 	}
     }
 
     return buf;
 }
 
 // Parses the format string and uses getFmtString to get the values for the tokens. Ret
 static QString fmtDateTime( const QString& f, const QTime* dt = 0, const QDate* dd = 0 )
 {
     if ( f.isEmpty() ) {
 	return QString::null;
     }
 
     bool ap = ( f.contains( "AP" ) || f.contains( "ap" ) );
 
     QString buf;
     QString frm;
     QChar status = '0';
 
     for ( int i = 0; i < (int)f.length(); ++i ) {
 
 	if ( f[ i ] == status ) {
 	    if ( ( ap ) && ( ( f[ i ] == 'P' ) || ( f[ i ] == 'p' ) ) )
 		status = '0';
 	    frm += f[ i ];
 	} else {
 	    buf += getFmtString( frm, dt, dd, ap );
 	    frm = QString::null;
 	    if ( ( f[ i ] == 'h' ) || ( f[ i ] == 'm' ) || ( f[ i ] == 's' ) || ( f[ i ] == 'z' ) ) {
 		status = f[ i ];
 		frm += f[ i ];
 	    } else if ( ( f[ i ] == 'd' ) || ( f[ i ] == 'M' ) || ( f[ i ] == 'y' ) ) {
 		status = f[ i ];
 		frm += f[ i ];
 	    } else if ( ( ap ) && ( f[ i ] == 'A' ) ) {
 		status = 'P';
 		frm += f[ i ];
 	    } else  if( ( ap ) && ( f[ i ] == 'a' ) ) {
 		status = 'p';
 		frm += f[ i ];
 	    } else {
 		buf += f[ i ];
 		status = '0';
 	    }
 	}
     }
 
     buf += getFmtString( frm, dt, dd, ap );
 
     return buf;
 }
 #endif // QT_NO_DATESTRING
 
 /*****************************************************************************
   QDate member functions
  *****************************************************************************/
 
 /*!
     \class QDate qdatetime.h
     \reentrant
     \brief The QDate class provides date functions.
 
     \ingroup time
     \mainclass
 
     A QDate object contains a calendar date, i.e. year, month, and day
     numbers, in the modern Western (Gregorian) calendar. It can read
     the current date from the system clock. It provides functions for
     comparing dates and for manipulating dates, e.g. by adding a
     number of days or months or years.
 
     A QDate object is typically created either by giving the year,
     month and day numbers explicitly, or by using the static function
     currentDate(), which creates a QDate object containing the system
     clock's date. An explicit date can also be set using setYMD(). The
     fromString() function returns a QDate given a string and a date
     format which is used to interpret the date within the string.
 
     The year(), month(), and day() functions provide access to the
     year, month, and day numbers. Also, dayOfWeek() and dayOfYear()
     functions are provided. The same information is provided in
     textual format by the toString(), shortDayName(), longDayName(),
     shortMonthName() and longMonthName() functions.
 
     QDate provides a full set of operators to compare two QDate
     objects where smaller means earlier and larger means later.
 
     You can increment (or decrement) a date by a given number of days
     using addDays(). Similarly you can use addMonths() and addYears().
     The daysTo() function returns the number of days between two
     dates.
 
     The daysInMonth() and daysInYear() functions return how many days
     there are in this date's month and year, respectively. The
     leapYear() function indicates whether this date is in a leap year.
 
     Note that QDate should not be used for date calculations for dates
     prior to the introduction of the Gregorian calendar. This calendar
     was adopted by England from the 14<sup><small>th</small></sup>
     September 1752 (hence this is the earliest valid QDate), and
     subsequently by most other Western countries, until 1923.
 
     The end of time is reached around the year 8000, by which time we
     expect Qt to be obsolete.
 
     \sa QTime QDateTime QDateEdit QDateTimeEdit
 */
 
 /*!
     \enum Qt::DateFormat
 
     \value TextDate (default) Qt format
     \value ISODate ISO 8601 extended format (YYYY-MM-DD, or with time,
     YYYY-MM-DDTHH:MM:SS)
     \value LocalDate locale dependent format
 */
 
 
 /*!
     \enum Qt::TimeSpec
 
     \value LocalTime Locale dependent time (Timezones and Daylight Savings Time)
     \value UTC Coordinated Universal Time, replaces Greenwich Time
 */
 
 /*!
     \fn QDate::QDate()
 
     Constructs a null date. Null dates are invalid.
 
     \sa isNull(), isValid()
 */
 
 
 /*!
     Constructs a date with year \a y, month \a m and day \a d.
 
     \a y must be in the range 1752..8000, \a m must be in the range
     1..12, and \a d must be in the range 1..31.
 
     \warning If \a y is in the range 0..99, it is interpreted as
     1900..1999.
 
     \sa isValid()
 */
 
 QDate::QDate( int y, int m, int d )
 {
     jd = 0;
     setYMD( y, m, d );
 }
 
 
 /*!
     \fn bool QDate::isNull() const
 
     Returns TRUE if the date is null; otherwise returns FALSE. A null
     date is invalid.
 
     \sa isValid()
 */
 
 
 /*!
     Returns TRUE if this date is valid; otherwise returns FALSE.
 
     \sa isNull()
 */
 
 bool QDate::isValid() const
 {
     return jd >= FIRST_DAY;
 }
 
 
 /*!
     Returns the year (1752..8000) of this date.
 
     \sa month(), day()
 */
 
 int QDate::year() const
 {
     int y, m, d;
     julianToGregorian( jd, y, m, d );
     return y;
 }
 
 /*!
     Returns the month (January=1..December=12) of this date.
 
     \sa year(), day()
 */
 
 int QDate::month() const
 {
     int y, m, d;
     julianToGregorian( jd, y, m, d );
     return m;
 }
 
 /*!
     Returns the day of the month (1..31) of this date.
 
     \sa year(), month(), dayOfWeek()
 */
 
 int QDate::day() const
 {
     int y, m, d;
     julianToGregorian( jd, y, m, d );
     return d;
 }
 
 /*!
     Returns the weekday (Monday=1..Sunday=7) for this date.
 
     \sa day(), dayOfYear()
 */
 
 int QDate::dayOfWeek() const
 {
     return ( jd % 7 ) + 1;
 }
 
 /*!
     Returns the day of the year (1..365) for this date.
 
     \sa day(), dayOfWeek()
 */
 
 int QDate::dayOfYear() const
 {
     return jd - gregorianToJulian(year(), 1, 1) + 1;
 }
 
 /*!
     Returns the number of days in the month (28..31) for this date.
 
     \sa day(), daysInYear()
 */
 
 int QDate::daysInMonth() const
 {
     int y, m, d;
     julianToGregorian( jd, y, m, d );
     if ( m == 2 && leapYear(y) )
 	return 29;
     else
 	return monthDays[m];
 }
 
 /*!
     Returns the number of days in the year (365 or 366) for this date.
 
     \sa day(), daysInMonth()
 */
 
 int QDate::daysInYear() const
 {
     int y, m, d;
     julianToGregorian( jd, y, m, d );
     return leapYear( y ) ? 366 : 365;
 }
 
 /*!
   Returns the week number (1 to 53), and stores the year in \a
   *yearNumber unless \a yearNumber is null (the default).
 
   Returns 0 if the date is invalid.
 
   In accordance with ISO 8601, weeks start on Monday and the first
   Thursday of a year is always in week 1 of that year. Most years
   have 52 weeks, but some have 53.
 
   \a *yearNumber is not always the same as year(). For example, 1
   January 2000 has week number 52 in the year 1999, and 31 December
   2002 has week number 1 in the year 2003.
 
   \sa isValid()
 */
 
 int QDate::weekNumber( int *yearNumber ) const
 {
     if ( !isValid() )
 	return 0;
 
     int dow = dayOfWeek();
     int doy = dayOfYear();
     int currYear = year();
     int jan1WeekDay = QDate( currYear, 1, 1 ).dayOfWeek();
     int yearNum;
     int weekNum;
 
     if ( doy <= (8 - jan1WeekDay) && jan1WeekDay > 4 ) {
 	yearNum = currYear - 1;
 	weekNum = 52;
 	if ( jan1WeekDay == 5 ||
 	     (jan1WeekDay == 6 && QDate::leapYear(yearNum)) )
 	    weekNum++;
     } else {
 	int totalDays = 365;
 	if ( QDate::leapYear(currYear) )
 	    totalDays++;
 
 	if ( (totalDays - doy < 4 - dow)
 	     || (jan1WeekDay == 7 && totalDays - doy < 3) ) {
 	    yearNum = currYear + 1;
 	    weekNum = 1;
 	} else {
 	    int j = doy + ( 7 - dow ) + ( jan1WeekDay - 1 );
 	    yearNum = currYear;
 	    weekNum = j / 7;
 	    if ( jan1WeekDay > 4 )
 		weekNum--;
 	}
     }
     if ( yearNumber )
 	*yearNumber = yearNum;
     return weekNum;
 }
 
 /*!
   \fn QString QDate::monthName( int month )
   \obsolete
 
   Use shortMonthName() instead.
 */
 #ifndef QT_NO_TEXTDATE
 /*!
     Returns the name of the \a month.
 
     1 = "Jan", 2 = "Feb", ... 12 = "Dec"
 
     The month names will be localized according to the system's locale
     settings.
 
     \sa toString(), longMonthName(), shortDayName(), longDayName()
 */
 
 QString QDate::shortMonthName( int month )
 {
 #if defined(QT_CHECK_RANGE)
     if ( month < 1 || month > 12 ) {
 	qWarning( "QDate::shortMonthName: Parameter out ouf range." );
 	month = 1;
     }
 #endif
 #ifndef Q_WS_WIN
     char buffer[255];
     tm tt;
     memset( &tt, 0, sizeof( tm ) );
     tt.tm_mon = month - 1;
     if ( strftime( buffer, sizeof( buffer ), "%b", &tt ) )
 	return QString::fromLocal8Bit( buffer );
 #else
     SYSTEMTIME st;
     memset( &st, 0, sizeof(SYSTEMTIME) );
     st.wYear = 2000;
     st.wMonth = month;
     st.wDay = 1;
     const wchar_t mmm_t[] = L"MMM"; // workaround for Borland
     QT_WA( {
 	TCHAR buf[255];
 	if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, mmm_t, buf, 255 ) )
 	    return QString::fromUcs2( (ushort*)buf );
     } , {
 	char buf[255];
 	if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "MMM", (char*)&buf, 255 ) )
 	    return QString::fromLocal8Bit( buf );
     } );
 #endif
     return QString::null;
 }
 
 /*!
     Returns the long name of the \a month.
 
     1 = "January", 2 = "February", ... 12 = "December"
 
     The month names will be localized according to the system's locale
     settings.
 
     \sa toString(), shortMonthName(), shortDayName(), longDayName()
 */
 
 QString QDate::longMonthName( int month )
 {
 #if defined(QT_CHECK_RANGE)
     if ( month < 1 || month > 12 ) {
 	qWarning( "QDate::longMonthName: Parameter out ouf range." );
 	month = 1;
     }
 #endif
 #ifndef Q_WS_WIN
     char buffer[255];
     tm tt;
     memset( &tt, 0, sizeof( tm ) );
     tt.tm_mon = month - 1;
     if ( strftime( buffer, sizeof( buffer ), "%B", &tt ) )
 	return QString::fromLocal8Bit( buffer );
 #else
     SYSTEMTIME st;
     memset( &st, 0, sizeof(SYSTEMTIME) );
     st.wYear = 2000;
     st.wMonth = month;
     st.wDay = 1 ;
     const wchar_t mmmm_t[] = L"MMMM"; // workaround for Borland
     QT_WA( {
 	TCHAR buf[255];
 	if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, mmmm_t, buf, 255 ) )
 	    return QString::fromUcs2( (ushort*)buf );
     } , {
 	char buf[255];
 	if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "MMMM", (char*)&buf, 255 ) )
 	    return QString::fromLocal8Bit( buf );
     } )
 #endif
 
     return QString::null;
 }
 
 /*!
   \fn QString QDate::dayName( int weekday )
   \obsolete
 
   Use shortDayName() instead.
 */
 
 /*!
     Returns the name of the \a weekday.
 
     1 = "Mon", 2 = "Tue", ... 7 = "Sun"
 
     The day names will be localized according to the system's locale
     settings.
 
     \sa toString(), shortMonthName(), longMonthName(), longDayName()
 */
 
 QString QDate::shortDayName( int weekday )
 {
 #if defined(QT_CHECK_RANGE)
     if ( weekday < 1 || weekday > 7 ) {
 	qWarning( "QDate::shortDayName: Parameter out of range." );
 	weekday = 1;
     }
 #endif
 #ifndef Q_WS_WIN
     char buffer[255];
     tm tt;
     memset( &tt, 0, sizeof( tm ) );
     tt.tm_wday = ( weekday == 7 ) ? 0 : weekday;
     if ( strftime( buffer, sizeof( buffer ), "%a", &tt ) )
 	return QString::fromLocal8Bit( buffer );
 #else
     SYSTEMTIME st;
     memset( &st, 0, sizeof(SYSTEMTIME) );
     st.wYear = 2001;
     st.wMonth = 10;
     st.wDayOfWeek = ( weekday == 7 ) ? 0 : weekday;
     st.wDay = 21 + st.wDayOfWeek;
     const wchar_t ddd_t[] = L"ddd"; // workaround for Borland
     QT_WA( {
 	TCHAR buf[255];
 	if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, ddd_t, buf, 255 ) )
 	    return QString::fromUcs2( (ushort*)buf );
     } , {
 	char buf[255];
 	if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "ddd", (char*)&buf, 255 ) )
 	    return QString::fromLocal8Bit( buf );
     } );
 #endif
 
     return QString::null;
 }
 
 /*!
     Returns the long name of the \a weekday.
 
     1 = "Monday", 2 = "Tuesday", ... 7 = "Sunday"
 
     The day names will be localized according to the system's locale
     settings.
 
     \sa toString(), shortDayName(), shortMonthName(), longMonthName()
 */
 
 QString QDate::longDayName( int weekday )
 {
 #if defined(QT_CHECK_RANGE)
     if ( weekday < 1 || weekday > 7 ) {
 	qWarning( "QDate::longDayName: Parameter out of range." );
 	weekday = 1;
     }
 #endif
 #ifndef Q_WS_WIN
     char buffer[255];
     tm tt;
     memset( &tt, 0, sizeof( tm ) );
     tt.tm_wday = ( weekday == 7 ) ? 0 : weekday;
     if ( strftime( buffer, sizeof( buffer ), "%A", &tt ) )
 	return QString::fromLocal8Bit( buffer );
 #else
     SYSTEMTIME st;
     memset( &st, 0, sizeof(SYSTEMTIME) );
     st.wYear = 2001;
     st.wMonth = 10;
     st.wDayOfWeek = ( weekday == 7 ) ? 0 : weekday;
     st.wDay = 21 + st.wDayOfWeek;
     const wchar_t dddd_t[] = L"dddd"; // workaround for Borland
     QT_WA( {
 	TCHAR buf[255];
 	if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, dddd_t, buf, 255 ) )
 	    return QString::fromUcs2( (ushort*)buf );
     } , {
 	char buf[255];
 	if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "dddd", (char*)&buf, 255 ) )
 	    return QString::fromLocal8Bit( buf );
     } );
 #endif
 
     return QString::null;
 }
 #endif //QT_NO_TEXTDATE
 
 #ifndef QT_NO_DATESTRING
 
 #if !defined(QT_NO_SPRINTF)
 /*!
     \overload
 
     Returns the date as a string. The \a f parameter determines the
     format of the string.
 
     If \a f is \c Qt::TextDate, the string format is "Sat May 20 1995"
     (using the shortDayName() and shortMonthName() functions to
     generate the string, so the day and month names are locale
     specific).
 
     If \a f is \c Qt::ISODate, the string format corresponds to the
     ISO 8601 specification for representations of dates, which is
     YYYY-MM-DD where YYYY is the year, MM is the month of the year
     (between 01 and 12), and DD is the day of the month between 01 and
     31.
 
     If \a f is \c Qt::LocalDate, the string format depends on the
     locale settings of the system.
 
     \sa shortDayName(), shortMonthName()
 */
 QString QDate::toString( Qt::DateFormat f ) const
 {
     int y, m, d;
     julianToGregorian( jd, y, m, d );
     switch ( f ) {
     case Qt::LocalDate:
 	{
 #ifndef Q_WS_WIN
 	    tm tt;
 	    memset( &tt, 0, sizeof( tm ) );
 	    char buf[255];
 	    tt.tm_mday = day();
 	    tt.tm_mon = month() - 1;
 	    tt.tm_year = year() - 1900;
 
 	    static const char * avoidEgcsWarning = "%x";
 	    if ( strftime( buf, sizeof(buf), avoidEgcsWarning, &tt ) )
 		return QString::fromLocal8Bit( buf );
 #else
 	    SYSTEMTIME st;
 	    memset( &st, 0, sizeof(SYSTEMTIME) );
 	    st.wYear = year();
 	    st.wMonth = month();
 	    st.wDay = day();
 	    QT_WA( {
 		TCHAR buf[255];
 		if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, 0, buf, 255 ) )
 		    return QString::fromUcs2( (ushort*)buf );
 	    } , {
 		char buf[255];
 		if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, 0, (char*)&buf, 255 ) )
 		    return QString::fromLocal8Bit( buf );
 	    } );
 #endif
 	    return QString::null;
 	}
     default:
 #ifndef QT_NO_TEXTDATE
     case Qt::TextDate:
 	{
 	    QString buf = shortDayName( dayOfWeek() );
 	    buf += ' ';
 	    buf += shortMonthName( m );
 	    QString t;
 	    t.sprintf( " %d %d", d, y );
 	    buf += t;
 	    return buf;
 	}
 #endif
     case Qt::ISODate:
 	{
 	    QString month( QString::number( m ).rightJustify( 2, '0' ) );
 	    QString day( QString::number( d ).rightJustify( 2, '0' ) );
 	    return QString::number( y ) + "-" + month + "-" + day;
 	}
     }
 }
 #endif //QT_NO_SPRINTF
 
 /*!
     Returns the date as a string. The \a format parameter determines
     the format of the result string.
 
     These expressions may be used:
 
     \table
     \header \i Expression \i Output
     \row \i d \i the day as number without a leading zero (1-31)
     \row \i dd \i the day as number with a leading zero (01-31)
     \row \i ddd
 	 \i the abbreviated localized day name (e.g. 'Mon'..'Sun').
 	    Uses QDate::shortDayName().
     \row \i dddd
 	 \i the long localized day name (e.g. 'Monday'..'Sunday').
 	    Uses QDate::longDayName().
     \row \i M \i the month as number without a leading zero (1-12)
     \row \i MM \i the month as number with a leading zero (01-12)
     \row \i MMM
 	 \i the abbreviated localized month name (e.g. 'Jan'..'Dec').
 	    Uses QDate::shortMonthName().
     \row \i MMMM
 	 \i the long localized month name (e.g. 'January'..'December').
 	    Uses QDate::longMonthName().
     \row \i yy \i the year as two digit number (00-99)
     \row \i yyyy \i the year as four digit number (1752-8000)
     \endtable
 
     All other input characters will be ignored.
 
     Example format strings (assuming that the QDate is the
     20<sup><small>th</small></sup> July 1969):
     \table
     \header \i Format \i Result
     \row \i dd.MM.yyyy	  \i11 20.07.1969
     \row \i ddd MMMM d yy \i11 Sun July 20 69
     \endtable
 
     \sa QDate::toString() QTime::toString()
 
 */
 QString QDate::toString( const QString& format ) const
 {
     return fmtDateTime( format, 0, this );
 }
 #endif //QT_NO_DATESTRING
 
 /*!
     Sets the date's year \a y, month \a m and day \a d.
 
     \a y must be in the range 1752..8000, \a m must be in the range
     1..12, and \a d must be in the range 1..31.
 
     \warning If \a y is in the range 0..99, it is interpreted as
     1900..1999.
 
     Returns TRUE if the date is valid; otherwise returns FALSE.
 */
 
 bool QDate::setYMD( int y, int m, int d )
 {
     if ( year() == y && month() == m && day() == d )
 	return isValid();
     if ( !isValid(y,m,d) ) {
 #if defined(QT_CHECK_RANGE)
 	 qWarning( "QDate::setYMD: Invalid date %04d-%02d-%02d", y, m, d );
 #endif
 	 return FALSE;
     }
     jd = gregorianToJulian( y, m, d );
     return TRUE;
 }
 
 /*!
     Returns a QDate object containing a date \a ndays later than the
     date of this object (or earlier if \a ndays is negative).
 
     \sa addMonths() addYears() daysTo()
 */
 
 QDate QDate::addDays( int ndays ) const
 {
     QDate d;
     d.jd = jd + ndays;
     return d;
 }
 
 /*!
     Returns a QDate object containing a date \a nmonths later than the
     date of this object (or earlier if \a nmonths is negative).
 
     \sa addDays() addYears()
 */
 
 QDate QDate::addMonths( int nmonths ) const
 {
     int y, m, d;
     julianToGregorian( jd, y, m, d );
 
     while ( nmonths != 0 ) {
 	if ( nmonths < 0 && nmonths + 12 <= 0 ) {
 	    y--;
 	    nmonths+=12;
 	} else if ( nmonths < 0 ) {
 	    m+= nmonths;
 	    nmonths = 0;
 	    if ( m <= 0 ) {
 		--y;
 		m+=12;
 	    }
 	} else if ( nmonths - 12 >= 0 ) {
 	    y++;
 	    nmonths-=12;
 	} else if ( m == 12 ) {
 	    y++;
 	    m = 0;
 	} else {
 	    m+= nmonths;
 	    nmonths = 0;
 	    if ( m > 12 ) {
 		++y;
 		m -= 12;
 	    }
 	}
     }
 
     QDate tmp(y,m,1);
 
     if( d > tmp.daysInMonth() )
 	d = tmp.daysInMonth();
 
     QDate date(y, m, d);
     return date;
 
 }
 
 /*!
     Returns a QDate object containing a date \a nyears later than the
     date of this object (or earlier if \a nyears is negative).
 
     \sa addDays(), addMonths()
 */
 
 QDate QDate::addYears( int nyears ) const
 {
     int y, m, d;
     julianToGregorian( jd, y, m, d );
     y += nyears;
+
+    QDate tmp(y,m,1);
+    
+    if( d > tmp.daysInMonth() )
+	d = tmp.daysInMonth();
+
     QDate date(y, m, d);
     return date;
 }
 
 
 
 /*!
     Returns the number of days from this date to \a d (which is
     negative if \a d is earlier than this date).
 
     Example:
     \code
 	QDate d1( 1995, 5, 17 );  // May 17th 1995
 	QDate d2( 1995, 5, 20 );  // May 20th 1995
 	d1.daysTo( d2 );          // returns 3
 	d2.daysTo( d1 );          // returns -3
     \endcode
 
     \sa addDays()
 */
 
 int QDate::daysTo( const QDate &d ) const
 {
     return d.jd - jd;
 }
 
 
 /*!
     \fn bool QDate::operator==( const QDate &d ) const
 
     Returns TRUE if this date is equal to \a d; otherwise returns FALSE.
 */
 
 /*!
     \fn bool QDate::operator!=( const QDate &d ) const
 
     Returns TRUE if this date is different from \a d; otherwise returns FALSE.
 */
 
 /*!
     \fn bool QDate::operator<( const QDate &d ) const
 
     Returns TRUE if this date is earlier than \a d, otherwise returns FALSE.
 */
 
 /*!
     \fn bool QDate::operator<=( const QDate &d ) const
 
     Returns TRUE if this date is earlier than or equal to \a d,
     otherwise returns FALSE.
 */
 
 /*!
     \fn bool QDate::operator>( const QDate &d ) const
 
     Returns TRUE if this date is later than \a d, otherwise returns FALSE.
 */
 
 /*!
     \fn bool QDate::operator>=( const QDate &d ) const
 
     Returns TRUE if this date is later than or equal to \a d,
     otherwise returns FALSE.
 */
 
 /*!
     \overload
     Returns the current date, as reported by the system clock.
 
     \sa QTime::currentTime(), QDateTime::currentDateTime()
 */
 
 QDate QDate::currentDate()
 {
     return currentDate( Qt::LocalTime );
 }
 
 /*!
   Returns the current date, as reported by the system clock, for the
   TimeSpec \a ts. The default TimeSpec is LocalTime.
 
   \sa QTime::currentTime(), QDateTime::currentDateTime(), Qt::TimeSpec
 */
 QDate QDate::currentDate( Qt::TimeSpec ts )
 {
     QDate d;
 #if defined(Q_OS_WIN32)
     SYSTEMTIME t;
     memset( &t, 0, sizeof(SYSTEMTIME) );
     if ( ts == Qt::LocalTime )
 	GetLocalTime( &t );
     else
 	GetSystemTime( &t );
     d.jd = gregorianToJulian( t.wYear, t.wMonth, t.wDay );
 #else
+    // posix compliant system
     time_t ltime;
     time( &ltime );
     tm *t;
+
+#  if defined(QT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
+    // use the reentrant versions of localtime() and gmtime() where available
+    tm res;
+    if ( ts == Qt::LocalTime )
+	t = localtime_r( &ltime, &res );
+    else
+	t = gmtime_r( &ltime, &res );
+#  else
     if ( ts == Qt::LocalTime )
 	t = localtime( &ltime );
-    else		
+    else
 	t = gmtime( &ltime );
+#  endif // QT_THREAD_SUPPORT && _POSIX_THREAD_SAFE_FUNCTIONS
+
     d.jd = gregorianToJulian( t->tm_year + 1900, t->tm_mon + 1, t->tm_mday );
 #endif
     return d;
 }
 
 #ifndef QT_NO_DATESTRING
 /*!
     Returns the QDate represented by the string \a s, using the format
     \a f, or an invalid date if the string cannot be parsed.
 
     Note for \c Qt::TextDate: It is recommended that you use the
     English short month names (e.g. "Jan"). Although localized month
     names can also be used, they depend on the user's locale settings.
 
     \warning \c Qt::LocalDate cannot be used here.
 */
 QDate QDate::fromString( const QString& s, Qt::DateFormat f )
 {
     if ( ( s.isEmpty() ) || ( f == Qt::LocalDate ) ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "QDate::fromString: Parameter out of range." );
 #endif
 	return QDate();
     }
     switch ( f ) {
     case Qt::ISODate:
 	{
 	    int year( s.mid( 0, 4 ).toInt() );
 	    int month( s.mid( 5, 2 ).toInt() );
 	    int day( s.mid( 8, 2 ).toInt() );
 	    if ( year && month && day )
 		return QDate( year, month, day );
 	}
 	break;
     default:
 #ifndef QT_NO_TEXTDATE
     case Qt::TextDate:
 	{
 	    /*
 	      This will fail gracefully if the input string doesn't
 	      contain any space.
 	    */
 	    int monthPos = s.find( ' ' ) + 1;
 	    int dayPos = s.find( ' ', monthPos ) + 1;
 
 	    QString monthName( s.mid(monthPos, dayPos - monthPos - 1) );
 	    int month = -1;
 
 	    // try English names first
 	    for ( int i = 0; i < 12; i++ ) {
 		if ( monthName == qt_shortMonthNames[i] ) {
 		    month = i + 1;
 		    break;
 		}
 	    }
 
 	    // try the localized names
 	    if ( month == -1 ) {
 		for ( int i = 0; i < 12; i++ ) {
 		    if ( monthName == shortMonthName( i + 1 ) ) {
 			month = i + 1;
 			break;
 		    }
 		}
 	    }
 #if defined(QT_CHECK_RANGE)
 	    if ( month < 1 || month > 12 ) {
 		qWarning( "QDate::fromString: Parameter out of range." );
 		month = 1;
 	    }
 #endif
 	    int day = s.mid( dayPos, 2 ).stripWhiteSpace().toInt();
 	    int year = s.right( 4 ).toInt();
 	    return QDate( year, month, day );
 	}
 #else
 	break;
 #endif
     }
     return QDate();
 }
 #endif //QT_NO_DATESTRING
 
 /*!
     \overload
 
     Returns TRUE if the specified date (year \a y, month \a m and day
     \a d) is valid; otherwise returns FALSE.
 
     Example:
     \code
     QDate::isValid( 2002, 5, 17 );  // TRUE   May 17th 2002 is valid
     QDate::isValid( 2002, 2, 30 );  // FALSE  Feb 30th does not exist
     QDate::isValid( 2004, 2, 29 );  // TRUE   2004 is a leap year
     QDate::isValid( 1202, 6, 6 );   // FALSE  1202 is pre-Gregorian
     \endcode
 
     \warning A \a y value in the range 00..99 is interpreted as
     1900..1999.
 
     \sa isNull(), setYMD()
 */
 
 bool QDate::isValid( int y, int m, int d )
 {
     if ( y >= 0 && y <= 99 )
 	y += 1900;
     else if ( y < FIRST_YEAR || (y == FIRST_YEAR && (m < 9 ||
 						    (m == 9 && d < 14))) )
 	return FALSE;
     return (d > 0 && m > 0 && m <= 12) &&
 	   (d <= monthDays[m] || (d == 29 && m == 2 && leapYear(y)));
 }
 
 /*!
     Returns TRUE if the specified year \a y is a leap year; otherwise
     returns FALSE.
 */
 
 bool QDate::leapYear( int y )
 {
     return y % 4 == 0 && y % 100 != 0 || y % 400 == 0;
 }
 
 /*!
   \internal
   Converts a Gregorian date to a Julian day.
   This algorithm is taken from Communications of the ACM, Vol 6, No 8.
   \sa julianToGregorian()
 */
 
 uint QDate::gregorianToJulian( int y, int m, int d )
 {
     uint c, ya;
     if ( y <= 99 )
 	y += 1900;
     if ( m > 2 ) {
 	m -= 3;
     } else {
 	m += 9;
 	y--;
     }
     c = y;					// NOTE: Sym C++ 6.0 bug
     c /= 100;
     ya = y - 100*c;
     return 1721119 + d + (146097*c)/4 + (1461*ya)/4 + (153*m+2)/5;
 }
 
 /*!
   \internal
   Converts a Julian day to a Gregorian date.
   This algorithm is taken from Communications of the ACM, Vol 6, No 8.
   \sa gregorianToJulian()
 */
 
 void QDate::julianToGregorian( uint jd, int &y, int &m, int &d )
 {
     uint x;
     uint j = jd - 1721119;
     y = (j*4 - 1)/146097;
     j = j*4 - 146097*y - 1;
     x = j/4;
     j = (x*4 + 3) / 1461;
     y = 100*y + j;
     x = (x*4) + 3 - 1461*j;
     x = (x + 4)/4;
     m = (5*x - 3)/153;
     x = 5*x - 3 - 153*m;
     d = (x + 5)/5;
     if ( m < 10 ) {
 	m += 3;
     } else {
 	m -= 9;
 	y++;
     }
 }
 
 
 /*****************************************************************************
   QTime member functions
  *****************************************************************************/
 
 /*!
     \class QTime qdatetime.h
     \reentrant
 
     \brief The QTime class provides clock time functions.
 
     \ingroup time
     \mainclass
 
     A QTime object contains a clock time, i.e. the number of hours,
     minutes, seconds, and milliseconds since midnight. It can read the
     current time from the system clock and measure a span of elapsed
     time. It provides functions for comparing times and for
     manipulating a time by adding a number of (milli)seconds.
 
     QTime uses the 24-hour clock format; it has no concept of AM/PM.
     It operates in local time; it knows nothing about time zones or
     daylight savings time.
 
     A QTime object is typically created either by giving the number of
     hours, minutes, seconds, and milliseconds explicitly, or by using
     the static function currentTime(), which creates a QTime object
     that contains the system's clock time. Note that the accuracy
     depends on the accuracy of the underlying operating system; not
     all systems provide 1-millisecond accuracy.
 
     The hour(), minute(), second(), and msec() functions provide
     access to the number of hours, minutes, seconds, and milliseconds
     of the time. The same information is provided in textual format by
     the toString() function.
 
     QTime provides a full set of operators to compare two QTime
     objects. One time is considered smaller than another if it is
     earlier than the other.
 
     The time a given number of seconds or milliseconds later than a
     given time can be found using the addSecs() or addMSecs()
     functions. Correspondingly, the number of (milli)seconds between
     two times can be found using the secsTo() or msecsTo() functions.
 
     QTime can be used to measure a span of elapsed time using the
     start(), restart(), and elapsed() functions.
 
     \sa QDate, QDateTime
 */
 
 /*!
     \fn QTime::QTime()
 
     Constructs the time 0 hours, minutes, seconds and milliseconds,
     i.e. 00:00:00.000 (midnight). This is a valid time.
 
     \sa isValid()
 */
 
 /*!
     Constructs a time with hour \a h, minute \a m, seconds \a s and
     milliseconds \a ms.
 
     \a h must be in the range 0..23, \a m and \a s must be in the
     range 0..59, and \a ms must be in the range 0..999.
 
     \sa isValid()
 */
 
 QTime::QTime( int h, int m, int s, int ms )
 {
     setHMS( h, m, s, ms );
 }
 
 
 /*!
     \fn bool QTime::isNull() const
 
     Returns TRUE if the time is equal to 00:00:00.000; otherwise
     returns FALSE. A null time is valid.
 
     \sa isValid()
 */
 
 /*!
     Returns TRUE if the time is valid; otherwise returns FALSE. The
     time 23:30:55.746 is valid, whereas 24:12:30 is invalid.
 
     \sa isNull()
 */
 
 bool QTime::isValid() const
 {
     return ds < MSECS_PER_DAY;
 }
 
 
 /*!
     Returns the hour part (0..23) of the time.
 */
 
 int QTime::hour() const
 {
     return ds / MSECS_PER_HOUR;
 }
 
 /*!
     Returns the minute part (0..59) of the time.
 */
 
 int QTime::minute() const
 {
     return (ds % MSECS_PER_HOUR)/MSECS_PER_MIN;
 }
 
 /*!
     Returns the second part (0..59) of the time.
 */
 
 int QTime::second() const
 {
     return (ds / 1000)%SECS_PER_MIN;
 }
 
 /*!
     Returns the millisecond part (0..999) of the time.
 */
 
 int QTime::msec() const
 {
     return ds % 1000;
 }
 
 #ifndef QT_NO_DATESTRING
 #ifndef QT_NO_SPRINTF
 /*!
     \overload
 
     Returns the time as a string. Milliseconds are not included. The
     \a f parameter determines the format of the string.
 
     If \a f is \c Qt::TextDate, the string format is HH:MM:SS; e.g. 1
     second before midnight would be "23:59:59".
 
     If \a f is \c Qt::ISODate, the string format corresponds to the
     ISO 8601 extended specification for representations of dates,
     which is also HH:MM:SS.
 
     If \a f is Qt::LocalDate, the string format depends on the locale
     settings of the system.
 */
 
 QString QTime::toString( Qt::DateFormat f ) const
 {
     switch ( f ) {
     case Qt::LocalDate:
 	{
 #ifndef Q_WS_WIN
 	    tm tt;
 	    memset( &tt, 0, sizeof( tm ) );
 	    char buf[255];
 	    tt.tm_sec = second();
 	    tt.tm_min = minute();
 	    tt.tm_hour = hour();
 	    if ( strftime( buf, sizeof(buf), "%X", &tt ) )
 		return QString::fromLocal8Bit( buf );
 #else
 	    SYSTEMTIME st;
 	    memset( &st, 0, sizeof(SYSTEMTIME) );
 	    st.wHour = hour();
 	    st.wMinute = minute();
 	    st.wSecond = second();
 	    st.wMilliseconds = 0;
 	    QT_WA( {
 		TCHAR buf[255];
 		if ( GetTimeFormat( LOCALE_USER_DEFAULT, 0, &st, 0, buf, 255 ) )
 		    return QString::fromUcs2( (ushort*)buf );
 	    } , {
 		char buf[255];
 		if ( GetTimeFormatA( LOCALE_USER_DEFAULT, 0, &st, 0, (char*)&buf, 255 ) )
 		    return QString::fromLocal8Bit( buf );
 	    } );
 #endif
 	    return QString::null;
 	}
     default:
     case Qt::ISODate:
     case Qt::TextDate:
 	QString buf;
 	buf.sprintf( "%.2d:%.2d:%.2d", hour(), minute(), second() );
 	return buf;
     }
 }
 #endif
 
 /*!
     Returns the time as a string. The \a format parameter determines
     the format of the result string.
 
     These expressions may be used:
 
     \table
     \header \i Expression \i Output
     \row \i h
 	 \i the hour without a leading zero (0..23 or 1..12 if AM/PM display)
     \row \i hh
 	 \i the hour with a leading zero (00..23 or 01..12 if AM/PM display)
     \row \i m \i the minute without a leading zero (0..59)
     \row \i mm \i the minute with a leading zero (00..59)
     \row \i s \i the second whithout a leading zero (0..59)
     \row \i ss \i the second whith a leading zero (00..59)
     \row \i z \i the milliseconds without leading zeroes (0..999)
     \row \i zzz \i the milliseconds with leading zeroes (000..999)
     \row \i AP
 	 \i use AM/PM display. \e AP will be replaced by either "AM" or "PM".
     \row \i ap
 	 \i use am/pm display. \e ap will be replaced by either "am" or "pm".
     \endtable
 
     All other input characters will be ignored.
 
     Example format strings (assuming that the QTime is 14:13:09.042)
 
     \table
     \header \i Format \i Result
     \row \i hh:mm:ss.zzz    \i11 14:13:09.042
     \row \i h:m:s ap	    \i11 2:13:9 pm
     \endtable
 
     \sa QDate::toString() QTime::toString()
 */
 QString QTime::toString( const QString& format ) const
 {
     return fmtDateTime( format, this, 0 );
 }
 #endif //QT_NO_DATESTRING
 /*!
     Sets the time to hour \a h, minute \a m, seconds \a s and
     milliseconds \a ms.
 
     \a h must be in the range 0..23, \a m and \a s must be in the
     range 0..59, and \a ms must be in the range 0..999. Returns TRUE
     if the set time is valid; otherwise returns FALSE.
 
     \sa isValid()
 */
 
 bool QTime::setHMS( int h, int m, int s, int ms )
 {
     if ( !isValid(h,m,s,ms) ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "QTime::setHMS Invalid time %02d:%02d:%02d.%03d", h, m, s,
 		 ms );
 #endif
 	ds = MSECS_PER_DAY;		// make this invalid
 	return FALSE;
     }
     ds = (h*SECS_PER_HOUR + m*SECS_PER_MIN + s)*1000 + ms;
     return TRUE;
 }
 
 /*!
     Returns a QTime object containing a time \a nsecs seconds later
     than the time of this object (or earlier if \a nsecs is negative).
 
     Note that the time will wrap if it passes midnight.
 
     Example:
     \code
     QTime n( 14, 0, 0 );                // n == 14:00:00
     QTime t;
     t = n.addSecs( 70 );                // t == 14:01:10
     t = n.addSecs( -70 );               // t == 13:58:50
     t = n.addSecs( 10*60*60 + 5 );      // t == 00:00:05
     t = n.addSecs( -15*60*60 );         // t == 23:00:00
     \endcode
 
     \sa addMSecs(), secsTo(), QDateTime::addSecs()
 */
 
 QTime QTime::addSecs( int nsecs ) const
 {
     return addMSecs( nsecs * 1000 );
 }
 
 /*!
     Returns the number of seconds from this time to \a t (which is
     negative if \a t is earlier than this time).
 
     Because QTime measures time within a day and there are 86400
     seconds in a day, the result is always between -86400 and 86400.
 
     \sa addSecs() QDateTime::secsTo()
 */
 
 int QTime::secsTo( const QTime &t ) const
 {
     return ((int)t.ds - (int)ds)/1000;
 }
 
 /*!
     Returns a QTime object containing a time \a ms milliseconds later
     than the time of this object (or earlier if \a ms is negative).
 
     Note that the time will wrap if it passes midnight. See addSecs()
     for an example.
 
     \sa addSecs(), msecsTo()
 */
 
 QTime QTime::addMSecs( int ms ) const
 {
     QTime t;
     if ( ms < 0 ) {
 	// % not well-defined for -ve, but / is.
 	int negdays = (MSECS_PER_DAY-ms) / MSECS_PER_DAY;
 	t.ds = ((int)ds + ms + negdays*MSECS_PER_DAY)
 		% MSECS_PER_DAY;
     } else {
 	t.ds = ((int)ds + ms) % MSECS_PER_DAY;
     }
     return t;
 }
 
 /*!
     Returns the number of milliseconds from this time to \a t (which
     is negative if \a t is earlier than this time).
 
     Because QTime measures time within a day and there are 86400
     seconds in a day, the result is always between -86400 and 86400s.
 
     \sa secsTo()
 */
 
 int QTime::msecsTo( const QTime &t ) const
 {
     return (int)t.ds - (int)ds;
 }
 
 
 /*!
     \fn bool QTime::operator==( const QTime &t ) const
 
     Returns TRUE if this time is equal to \a t; otherwise returns FALSE.
 */
 
 /*!
     \fn bool QTime::operator!=( const QTime &t ) const
 
     Returns TRUE if this time is different from \a t; otherwise returns FALSE.
 */
 
 /*!
     \fn bool QTime::operator<( const QTime &t ) const
 
     Returns TRUE if this time is earlier than \a t; otherwise returns FALSE.
 */
 
 /*!
     \fn bool QTime::operator<=( const QTime &t ) const
 
     Returns TRUE if this time is earlier than or equal to \a t;
     otherwise returns FALSE.
 */
 
 /*!
     \fn bool QTime::operator>( const QTime &t ) const
 
     Returns TRUE if this time is later than \a t; otherwise returns FALSE.
 */
 
 /*!
     \fn bool QTime::operator>=( const QTime &t ) const
 
     Returns TRUE if this time is later than or equal to \a t;
     otherwise returns FALSE.
 */
 
 
 
-/*!  
+/*!
     \overload
 
     Returns the current time as reported by the system clock.
 
     Note that the accuracy depends on the accuracy of the underlying
     operating system; not all systems provide 1-millisecond accuracy.
 */
 
 QTime QTime::currentTime()
 {
     return currentTime( Qt::LocalTime );
 }
 
 /*!
   Returns the current time as reported by the system clock, for the
   TimeSpec \a ts. The default TimeSpec is LocalTime.
 
   Note that the accuracy depends on the accuracy of the underlying
   operating system; not all systems provide 1-millisecond accuracy.
 
   \sa Qt::TimeSpec
 */
 QTime QTime::currentTime( Qt::TimeSpec ts )
 {
     QTime t;
     currentTime( &t, ts );
     return t;
 }
 
 #ifndef QT_NO_DATESTRING
 /*!
     Returns the representation \a s as a QTime using the format \a f,
     or an invalid time if this is not possible.
 
     \warning Note that \c Qt::LocalDate cannot be used here.
 */
 QTime QTime::fromString( const QString& s, Qt::DateFormat f )
 {
     if ( ( s.isEmpty() ) || ( f == Qt::LocalDate ) ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "QTime::fromString: Parameter out of range." );
 #endif
 	return QTime();
     }
 
     int hour( s.mid( 0, 2 ).toInt() );
     int minute( s.mid( 3, 2 ).toInt() );
     int second( s.mid( 6, 2 ).toInt() );
     int msec( s.mid( 9, 3 ).toInt() );
     return QTime( hour, minute, second, msec );
 }
 #endif
 
 /*!
   \internal
   \obsolete
 
   Fetches the current time and returns TRUE if the time is within one
   minute after midnight, otherwise FALSE. The return value is used by
   QDateTime::currentDateTime() to ensure that the date there is correct.
 */
 
 bool QTime::currentTime( QTime *ct )
 {
     return currentTime( ct, Qt::LocalTime );
 }
 
 
 /*!
   \internal
 
   Fetches the current time, for the TimeSpec \a ts, and returns TRUE
   if the time is within one minute after midnight, otherwise FALSE. The
   return value is used by QDateTime::currentDateTime() to ensure that
   the date there is correct. The default TimeSpec is LocalTime.
 
   \sa Qt::TimeSpec
 */
 bool QTime::currentTime( QTime *ct, Qt::TimeSpec ts )
 {
     if ( !ct ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QTime::currentTime(QTime *): Null pointer not allowed" );
 #endif
 	return FALSE;
     }
 
 #if defined(Q_OS_WIN32)
     SYSTEMTIME t;
     if ( ts == Qt::LocalTime ) {
 	GetLocalTime( &t );
     } else {
 	GetSystemTime( &t );
     }
     ct->ds = (uint)( MSECS_PER_HOUR*t.wHour + MSECS_PER_MIN*t.wMinute +
 		     1000*t.wSecond + t.wMilliseconds );
 #elif defined(Q_OS_UNIX)
+    // posix compliant system
     struct timeval tv;
     gettimeofday( &tv, 0 );
     time_t ltime = tv.tv_sec;
     tm *t;
-    if ( ts == Qt::LocalTime ) {
+
+#  if defined(QT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
+    // use the reentrant versions of localtime() and gmtime() where available
+    tm res;
+    if ( ts == Qt::LocalTime )
+	t = localtime_r( &ltime, &res );
+    else
+	t = gmtime_r( &ltime, &res );
+#  else
+    if ( ts == Qt::LocalTime )
 	t = localtime( &ltime );
-    } else {
+    else
 	t = gmtime( &ltime );
-    }
+#  endif // QT_THREAD_SUPPORT && _POSIX_THREAD_SAFE_FUNCTIONS
+
     ct->ds = (uint)( MSECS_PER_HOUR * t->tm_hour + MSECS_PER_MIN * t->tm_min +
 		     1000 * t->tm_sec + tv.tv_usec / 1000 );
 #else
     time_t ltime; // no millisecond resolution
     ::time( &ltime );
     tm *t;
-    if ( ts == Qt::LocalTime ) 
+    if ( ts == Qt::LocalTime )
 	localtime( &ltime );
     else
 	gmtime( &ltime );
     ct->ds = (uint) ( MSECS_PER_HOUR * t->tm_hour + MSECS_PER_MIN * t->tm_min +
 		      1000 * t->tm_sec );
 #endif
     // 00:00.00 to 00:00.59.999 is considered as "midnight or right after"
     return ct->ds < (uint) MSECS_PER_MIN;
 }
 
 /*!
     \overload
 
     Returns TRUE if the specified time is valid; otherwise returns
     FALSE.
 
     The time is valid if \a h is in the range 0..23, \a m and \a s are
     in the range 0..59, and \a ms is in the range 0..999.
 
     Example:
     \code
     QTime::isValid(21, 10, 30); // returns TRUE
     QTime::isValid(22, 5,  62); // returns FALSE
     \endcode
 */
 
 bool QTime::isValid( int h, int m, int s, int ms )
 {
     return (uint)h < 24 && (uint)m < 60 && (uint)s < 60 && (uint)ms < 1000;
 }
 
 
 /*!
     Sets this time to the current time. This is practical for timing:
 
     \code
     QTime t;
-    t.start();                     // start clock
-    ... // some lengthy task
-    qDebug( "%d\n", t.elapsed() ); // prints the number of msecs elapsed
+    t.start();
+    some_lengthy_task();
+    qDebug( "Time elapsed: %d ms", t.elapsed() );
     \endcode
 
     \sa restart(), elapsed(), currentTime()
 */
 
 void QTime::start()
 {
     *this = currentTime();
 }
 
 /*!
     Sets this time to the current time and returns the number of
     milliseconds that have elapsed since the last time start() or
     restart() was called.
 
     This function is guaranteed to be atomic and is thus very handy
     for repeated measurements. Call start() to start the first
     measurement and then restart() for each later measurement.
 
     Note that the counter wraps to zero 24 hours after the last call
     to start() or restart().
 
     \warning If the system's clock setting has been changed since the
     last time start() or restart() was called, the result is
     undefined. This can happen when daylight savings time is turned on
     or off.
 
     \sa start(), elapsed(), currentTime()
 */
 
 int QTime::restart()
 {
     QTime t = currentTime();
     int n = msecsTo( t );
     if ( n < 0 )				// passed midnight
 	n += 86400*1000;
     *this = t;
     return n;
 }
 
 /*!
     Returns the number of milliseconds that have elapsed since the
     last time start() or restart() was called.
 
     Note that the counter wraps to zero 24 hours after the last call
     to start() or restart.
 
     Note that the accuracy depends on the accuracy of the underlying
     operating system; not all systems provide 1-millisecond accuracy.
 
     \warning If the system's clock setting has been changed since the
     last time start() or restart() was called, the result is
     undefined. This can happen when daylight savings time is turned on
     or off.
 
     \sa start(), restart()
 */
 
 int QTime::elapsed() const
 {
     int n = msecsTo( currentTime() );
     if ( n < 0 )				// passed midnight
 	n += 86400*1000;
     return n;
 }
 
 
 /*****************************************************************************
   QDateTime member functions
  *****************************************************************************/
 
 /*!
     \class QDateTime qdatetime.h
     \reentrant
     \brief The QDateTime class provides date and time functions.
 
     \ingroup time
     \mainclass
 
     A QDateTime object contains a calendar date and a clock time (a
     "datetime"). It is a combination of the QDate and QTime classes.
     It can read the current datetime from the system clock. It
     provides functions for comparing datetimes and for manipulating a
     datetime by adding a number of seconds, days, months or years.
 
     A QDateTime object is typically created either by giving a date
     and time explicitly in the constructor, or by using the static
     function currentDateTime(), which returns a QDateTime object set
     to the system clock's time. The date and time can be changed with
     setDate() and setTime(). A datetime can also be set using the
     setTime_t() function, which takes a POSIX-standard "number of
     seconds since 00:00:00 on January 1, 1970" value. The fromString()
     function returns a QDateTime given a string and a date format
     which is used to interpret the date within the string.
 
     The date() and time() functions provide access to the date and
     time parts of the datetime. The same information is provided in
     textual format by the toString() function.
 
     QDateTime provides a full set of operators to compare two
     QDateTime objects where smaller means earlier and larger means
     later.
 
     You can increment (or decrement) a datetime by a given number of
     seconds using addSecs() or days using addDays(). Similarly you can
     use addMonths() and addYears(). The daysTo() function returns the
     number of days between two datetimes, and secsTo() returns the
     number of seconds between two datetimes.
 
     The range of a datetime object is constrained to the ranges of the
     QDate and QTime objects which it embodies.
 
     \sa QDate QTime QDateTimeEdit
 */
 
 
 /*!
     \fn QDateTime::QDateTime()
 
     Constructs a null datetime (i.e. null date and null time). A null
     datetime is invalid, since the date is invalid.
 
     \sa isValid()
 */
 
 
 /*!
     Constructs a datetime with date \a date and null (but valid) time
     (00:00:00.000).
 */
 
 QDateTime::QDateTime( const QDate &date )
     : d(date)
 {
 }
 
 /*!
     Constructs a datetime with date \a date and time \a time.
 */
 
 QDateTime::QDateTime( const QDate &date, const QTime &time )
     : d(date), t(time)
 {
 }
 
 
 /*!
     \fn bool QDateTime::isNull() const
 
     Returns TRUE if both the date and the time are null; otherwise
     returns FALSE. A null datetime is invalid.
 
     \sa QDate::isNull(), QTime::isNull()
 */
 
 /*!
     \fn bool QDateTime::isValid() const
 
     Returns TRUE if both the date and the time are valid; otherwise
     returns FALSE.
 
     \sa QDate::isValid(), QTime::isValid()
 */
 
 /*!
     \fn QDate QDateTime::date() const
 
     Returns the date part of the datetime.
 
     \sa setDate(), time()
 */
 
 /*!
     \fn QTime QDateTime::time() const
 
     Returns the time part of the datetime.
 
     \sa setTime(), date()
 */
 
 /*!
     \fn void QDateTime::setDate( const QDate &date )
 
     Sets the date part of this datetime to \a date.
 
     \sa date(), setTime()
 */
 
 /*!
     \fn void QDateTime::setTime( const QTime &time )
 
     Sets the time part of this datetime to \a time.
 
     \sa time(), setDate()
 */
 
 
 /*!
     Returns the datetime as the number of seconds that have passed
     since 1970-01-01T00:00:00, Coordinated Universal Time (UTC).
 
     On systems that do not support timezones, this function will
     behave as if local time were UTC.
 
     \sa setTime_t()
 */
 
 uint QDateTime::toTime_t() const
 {
     tm brokenDown;
     brokenDown.tm_sec = t.second();
     brokenDown.tm_min = t.minute();
     brokenDown.tm_hour = t.hour();
     brokenDown.tm_mday = d.day();
     brokenDown.tm_mon = d.month() - 1;
     brokenDown.tm_year = d.year() - 1900;
     brokenDown.tm_isdst = -1;
     int secsSince1Jan1970UTC = (int) mktime( &brokenDown );
     if ( secsSince1Jan1970UTC < -1 )
 	secsSince1Jan1970UTC = -1;
     return (uint) secsSince1Jan1970UTC;
 }
 
 /*!
     \overload
 
     Convenience function that sets the date and time to local time
     based on the given UTC time.
 */
 
 void QDateTime::setTime_t( uint secsSince1Jan1970UTC )
 {
     setTime_t( secsSince1Jan1970UTC, Qt::LocalTime );
 }
 
 /*!
     Sets the date and time to \a ts time (\c Qt::LocalTime or \c
     Qt::UTC) given the number of seconds that have passed since
     1970-01-01T00:00:00, Coordinated Universal Time (UTC). On systems
     that do not support timezones this function will behave as if
     local time were UTC.
 
     On Windows, only a subset of \a secsSince1Jan1970UTC values are
     supported, as Windows starts counting from 1980.
 
     \sa toTime_t()
 */
 void QDateTime::setTime_t( uint secsSince1Jan1970UTC, Qt::TimeSpec ts )
 {
     time_t tmp = (time_t) secsSince1Jan1970UTC;
     tm *brokenDown = 0;
+
+#if defined(Q_OS_UNIX) && defined(QT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
+    // posix compliant system
+    // use the reentrant versions of localtime() and gmtime() where available
+    tm res;
+    if ( ts == Qt::LocalTime )
+	brokenDown = localtime_r( &tmp, &res );
+    if ( !brokenDown ) {
+	brokenDown = gmtime_r( &tmp, &res );
+	if ( !brokenDown ) {
+	    d.jd = QDate::gregorianToJulian( 1970, 1, 1 );
+	    t.ds = 0;
+	    return;
+	}
+    }
+#else
     if ( ts == Qt::LocalTime )
 	brokenDown = localtime( &tmp );
     if ( !brokenDown ) {
 	brokenDown = gmtime( &tmp );
 	if ( !brokenDown ) {
 	    d.jd = QDate::gregorianToJulian( 1970, 1, 1 );
 	    t.ds = 0;
 	    return;
 	}
     }
+#endif
+
     d.jd = QDate::gregorianToJulian( brokenDown->tm_year + 1900,
 				     brokenDown->tm_mon + 1,
 				     brokenDown->tm_mday );
     t.ds = MSECS_PER_HOUR * brokenDown->tm_hour +
 	   MSECS_PER_MIN * brokenDown->tm_min +
 	   1000 * brokenDown->tm_sec;
 }
 #ifndef QT_NO_DATESTRING
 #ifndef QT_NO_SPRINTF
 /*!
     \overload
 
     Returns the datetime as a string. The \a f parameter determines
     the format of the string.
 
     If \a f is \c Qt::TextDate, the string format is "Wed May 20
     03:40:13 1998" (using QDate::shortDayName(), QDate::shortMonthName(),
     and QTime::toString() to generate the string, so the day and month
     names will have localized names).
 
     If \a f is \c Qt::ISODate, the string format corresponds to the
     ISO 8601 extended specification for representations of dates and
     times, which is YYYY-MM-DDTHH:MM:SS.
 
     If \a f is \c Qt::LocalDate, the string format depends on the
     locale settings of the system.
 
     If the format \a f is invalid, toString() returns a null string.
 
     \sa QDate::toString() QTime::toString()
 */
 
 QString QDateTime::toString( Qt::DateFormat f ) const
 {
     if ( f == Qt::ISODate ) {
 	return d.toString( Qt::ISODate ) + "T" + t.toString( Qt::ISODate );
     }
 #ifndef QT_NO_TEXTDATE
     else if ( f == Qt::TextDate ) {
 #ifndef Q_WS_WIN
 	QString buf = d.shortDayName( d.dayOfWeek() );
 	buf += ' ';
 	buf += d.shortMonthName( d.month() );
 	buf += ' ';
 	buf += QString().setNum( d.day() );
 	buf += ' ';
 #else
 	QString buf;
 	QString winstr;
 	QT_WA( {
 	    TCHAR out[255];
 	    GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_ILDATE, out, 255 );
 	    winstr = QString::fromUcs2( (ushort*)out );
 	} , {
 	    char out[255];
 	    GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_ILDATE, (char*)&out, 255 );
 	    winstr = QString::fromLocal8Bit( out );
 	} );
 	switch ( winstr.toInt() ) {
 	case 1:
 	    buf = d.shortDayName( d.dayOfWeek() ) + " " + QString().setNum( d.day() ) + ". " + d.shortMonthName( d.month() ) + " ";
 	    break;
 	default:
 	    buf = d.shortDayName( d.dayOfWeek() ) + " " + d.shortMonthName( d.month() ) + " " + QString().setNum( d.day() ) + " ";
 	    break;
 	}
 #endif
 	buf += t.toString();
 	buf += ' ';
 	buf += QString().setNum( d.year() );
 	return buf;
     }
 #endif
     else if ( f == Qt::LocalDate ) {
 	return d.toString( Qt::LocalDate ) + " " + t.toString( Qt::LocalDate );
     }
     return QString::null;
 }
 #endif
 
 /*!
     Returns the datetime as a string. The \a format parameter
     determines the format of the result string.
 
     These expressions may be used for the date:
 
     \table
     \header \i Expression \i Output
     \row \i d \i the day as number without a leading zero (1-31)
     \row \i dd \i the day as number with a leading zero (01-31)
     \row \i ddd
 	    \i the abbreviated localized day name (e.g. 'Mon'..'Sun').
 	    Uses QDate::shortDayName().
     \row \i dddd
 	    \i the long localized day name (e.g. 'Monday'..'Sunday').
 	    Uses QDate::longDayName().
     \row \i M \i the month as number without a leading zero (1-12)
     \row \i MM \i the month as number with a leading zero (01-12)
     \row \i MMM
 	    \i the abbreviated localized month name (e.g. 'Jan'..'Dec').
 	    Uses QDate::shortMonthName().
     \row \i MMMM
 	    \i the long localized month name (e.g. 'January'..'December').
 	    Uses QDate::longMonthName().
     \row \i yy \i the year as two digit number (00-99)
     \row \i yyyy \i the year as four digit number (1752-8000)
     \endtable
 
     These expressions may be used for the time:
 
     \table
     \header \i Expression \i Output
     \row \i h
 	    \i the hour without a leading zero (0..23 or 1..12 if AM/PM display)
     \row \i hh
 	    \i the hour with a leading zero (00..23 or 01..12 if AM/PM display)
     \row \i m \i the minute without a leading zero (0..59)
     \row \i mm \i the minute with a leading zero (00..59)
     \row \i s \i the second whithout a leading zero (0..59)
     \row \i ss \i the second whith a leading zero (00..59)
     \row \i z \i the milliseconds without leading zeroes (0..999)
     \row \i zzz \i the milliseconds with leading zeroes (000..999)
     \row \i AP
 	    \i use AM/PM display. \e AP will be replaced by either "AM" or "PM".
     \row \i ap
 	    \i use am/pm display. \e ap will be replaced by either "am" or "pm".
     \endtable
 
     All other input characters will be ignored.
 
     Example format strings (assumed that the QDateTime is
     21<small><sup>st</sup></small> May 2001 14:13:09)
 
     \table
     \header \i Format \i Result
     \row \i dd.MM.yyyy	    \i11 21.05.2001
     \row \i ddd MMMM d yy   \i11 Tue May 21 01
     \row \i hh:mm:ss.zzz    \i11 14:13:09.042
     \row \i h:m:s ap	    \i11 2:13:9 pm
     \endtable
 
     \sa QDate::toString() QTime::toString()
 */
 QString QDateTime::toString( const QString& format ) const
 {
     return fmtDateTime( format, &t, &d );
 }
 #endif //QT_NO_DATESTRING
 
 /*!
     Returns a QDateTime object containing a datetime \a ndays days
     later than the datetime of this object (or earlier if \a ndays is
     negative).
 
     \sa daysTo(), addMonths(), addYears(), addSecs()
 */
 
 QDateTime QDateTime::addDays( int ndays ) const
 {
     return QDateTime( d.addDays(ndays), t );
 }
 
 /*!
     Returns a QDateTime object containing a datetime \a nmonths months
     later than the datetime of this object (or earlier if \a nmonths
     is negative).
 
     \sa daysTo(), addDays(), addYears(), addSecs()
 */
 
 QDateTime QDateTime::addMonths( int nmonths ) const
 {
     return QDateTime( d.addMonths(nmonths), t );
 }
 
 /*!
     Returns a QDateTime object containing a datetime \a nyears years
     later than the datetime of this object (or earlier if \a nyears is
     negative).
 
     \sa daysTo(), addDays(), addMonths(), addSecs()
 */
 
 QDateTime QDateTime::addYears( int nyears ) const
 {
     return QDateTime( d.addYears(nyears), t );
 }
 
 /*!
     Returns a QDateTime object containing a datetime \a nsecs seconds
     later than the datetime of this object (or earlier if \a nsecs is
     negative).
 
     \sa secsTo(), addDays(), addMonths(), addYears()
 */
 
 QDateTime QDateTime::addSecs( int nsecs ) const
 {
     uint dd = d.jd;
     int  tt = t.ds;
     int  sign = 1;
     if ( nsecs < 0 ) {
 	nsecs = -nsecs;
 	sign = -1;
     }
     if ( nsecs >= (int)SECS_PER_DAY ) {
 	dd += sign*(nsecs/SECS_PER_DAY);
 	nsecs %= SECS_PER_DAY;
     }
     tt += sign*nsecs*1000;
     if ( tt < 0 ) {
 	tt = MSECS_PER_DAY - tt - 1;
 	dd -= tt / MSECS_PER_DAY;
 	tt = tt % MSECS_PER_DAY;
 	tt = MSECS_PER_DAY - tt - 1;
     } else if ( tt >= (int)MSECS_PER_DAY ) {
 	dd += ( tt / MSECS_PER_DAY );
 	tt = tt % MSECS_PER_DAY;
     }
     QDateTime ret;
     ret.t.ds = tt;
     ret.d.jd = dd;
     return ret;
 }
 
 /*!
     Returns the number of days from this datetime to \a dt (which is
     negative if \a dt is earlier than this datetime).
 
     \sa addDays(), secsTo()
 */
 
 int QDateTime::daysTo( const QDateTime &dt ) const
 {
     return d.daysTo( dt.d );
 }
 
 /*!
     Returns the number of seconds from this datetime to \a dt (which
     is negative if \a dt is earlier than this datetime).
 
     Example:
     \code
     QDateTime dt = QDateTime::currentDateTime();
     QDateTime xmas( QDate(dt.year(),12,24), QTime(17,00) );
     qDebug( "There are %d seconds to Christmas", dt.secsTo(xmas) );
     \endcode
 
     \sa addSecs(), daysTo(), QTime::secsTo()
 */
 
 int QDateTime::secsTo( const QDateTime &dt ) const
 {
     return t.secsTo(dt.t) + d.daysTo(dt.d)*SECS_PER_DAY;
 }
 
 
 /*!
     Returns TRUE if this datetime is equal to \a dt; otherwise returns FALSE.
 
     \sa operator!=()
 */
 
 bool QDateTime::operator==( const QDateTime &dt ) const
 {
     return  t == dt.t && d == dt.d;
 }
 
 /*!
     Returns TRUE if this datetime is different from \a dt; otherwise
     returns FALSE.
 
     \sa operator==()
 */
 
 bool QDateTime::operator!=( const QDateTime &dt ) const
 {
     return  t != dt.t || d != dt.d;
 }
 
 /*!
     Returns TRUE if this datetime is earlier than \a dt; otherwise
     returns FALSE.
 */
 
 bool QDateTime::operator<( const QDateTime &dt ) const
 {
     if ( d < dt.d )
 	return TRUE;
     return d == dt.d ? t < dt.t : FALSE;
 }
 
 /*!
     Returns TRUE if this datetime is earlier than or equal to \a dt;
     otherwise returns FALSE.
 */
 
 bool QDateTime::operator<=( const QDateTime &dt ) const
 {
     if ( d < dt.d )
 	return TRUE;
     return d == dt.d ? t <= dt.t : FALSE;
 }
 
 /*!
     Returns TRUE if this datetime is later than \a dt; otherwise
     returns FALSE.
 */
 
 bool QDateTime::operator>( const QDateTime &dt ) const
 {
     if ( d > dt.d )
 	return TRUE;
     return d == dt.d ? t > dt.t : FALSE;
 }
 
 /*!
     Returns TRUE if this datetime is later than or equal to \a dt;
     otherwise returns FALSE.
 */
 
 bool QDateTime::operator>=( const QDateTime &dt ) const
 {
     if ( d > dt.d )
 	return TRUE;
     return d == dt.d ? t >= dt.t : FALSE;
 }
 
 /*!
     \overload
-    
+
     Returns the current datetime, as reported by the system clock.
 
     \sa QDate::currentDate(), QTime::currentTime()
 */
 
 QDateTime QDateTime::currentDateTime()
 {
     return currentDateTime( Qt::LocalTime );
 }
 
 /*!
   Returns the current datetime, as reported by the system clock, for the
   TimeSpec \a ts. The default TimeSpec is LocalTime.
 
   \sa QDate::currentDate(), QTime::currentTime(), Qt::TimeSpec
 */
 
 QDateTime QDateTime::currentDateTime( Qt::TimeSpec ts )
 {
     QDateTime dt;
     QTime t;
     dt.setDate( QDate::currentDate(ts) );
     if ( QTime::currentTime(&t, ts) )         // midnight or right after?
 	dt.setDate( QDate::currentDate(ts) ); // fetch date again
     dt.setTime( t );
     return dt;
 }
 
 #ifndef QT_NO_DATESTRING
 /*!
     Returns the QDateTime represented by the string \a s, using the
     format \a f, or an invalid datetime if this is not possible.
 
     Note for \c Qt::TextDate: It is recommended that you use the
     English short month names (e.g. "Jan"). Although localized month
     names can also be used, they depend on the user's locale settings.
 
     \warning Note that \c Qt::LocalDate cannot be used here.
 */
 QDateTime QDateTime::fromString( const QString& s, Qt::DateFormat f )
 {
     if ( ( s.isEmpty() ) || ( f == Qt::LocalDate ) ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "QDateTime::fromString: Parameter out of range" );
 #endif
 	return QDateTime();
     }
     if ( f == Qt::ISODate ) {
 	return QDateTime( QDate::fromString( s.mid(0,10), Qt::ISODate ),
 			  QTime::fromString( s.mid(11), Qt::ISODate ) );
     }
 #if !defined(QT_NO_REGEXP) && !defined(QT_NO_TEXTDATE)
     else if ( f == Qt::TextDate ) {
 	QString monthName( s.mid( 4, 3 ) );
 	int month = -1;
 	// Assume that English monthnames are the default
 	for ( int i = 0; i < 12; ++i ) {
 	    if ( monthName == qt_shortMonthNames[i] ) {
 		month = i + 1;
 		break;
 	    }
 	}
 	// If English names can't be found, search the localized ones
 	if ( month == -1 ) {
 	    for ( int i = 1; i <= 12; ++i ) {
 		if ( monthName == QDate::shortMonthName( i ) ) {
 		    month = i;
 		    break;
 		}
 	    }
 	}
 #if defined(QT_CHECK_RANGE)
 	if ( month < 1 || month > 12 ) {
 	    qWarning( "QDateTime::fromString: Parameter out of range." );
 	    month = 1;
 	}
 #endif
 	int day = s.mid( 8, 2 ).simplifyWhiteSpace().toInt();
 	int year = s.right( 4 ).toInt();
 	QDate date( year, month, day );
 	QTime time;
 	int hour, minute, second;
 	int pivot = s.find( QRegExp("[0-9][0-9]:[0-9][0-9]:[0-9][0-9]") );
 	if ( pivot != -1 ) {
 	    hour = s.mid( pivot, 2 ).toInt();
 	    minute = s.mid( pivot+3, 2 ).toInt();
 	    second = s.mid( pivot+6, 2 ).toInt();
 	    time.setHMS( hour, minute, second );
 	}
 	return QDateTime( date, time );
     }
 #endif //QT_NO_REGEXP
     return QDateTime();
 }
 #endif //QT_NO_DATESTRING
 
 
 /*****************************************************************************
   Date/time stream functions
  *****************************************************************************/
 
 #ifndef QT_NO_DATASTREAM
 /*!
     \relates QDate
 
     Writes the date, \a d, to the data stream, \a s.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator<<( QDataStream &s, const QDate &d )
 {
     return s << (Q_UINT32)(d.jd);
 }
 
 /*!
     \relates QDate
 
     Reads a date from the stream \a s into \a d.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator>>( QDataStream &s, QDate &d )
 {
     Q_UINT32 jd;
     s >> jd;
     d.jd = jd;
     return s;
 }
 
 /*!
     \relates QTime
 
     Writes time \a t to the stream \a s.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator<<( QDataStream &s, const QTime &t )
 {
     return s << (Q_UINT32)(t.ds);
 }
 
 /*!
     \relates QTime
 
     Reads a time from the stream \a s into \a t.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator>>( QDataStream &s, QTime &t )
 {
     Q_UINT32 ds;
     s >> ds;
     t.ds = ds;
     return s;
 }
 
 /*!
     \relates QDateTime
 
     Writes the datetime \a dt to the stream \a s.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator<<( QDataStream &s, const QDateTime &dt )
 {
     return s << dt.d << dt.t;
 }
 
 /*!
     \relates QDateTime
 
     Reads a datetime from the stream \a s into \a dt.
 
     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator>>( QDataStream &s, QDateTime &dt )
 {
     s >> dt.d >> dt.t;
     return s;
 }
 #endif //QT_NO_DATASTREAM
diff --git a/qmake/tools/qdir.cpp b/qmake/tools/qdir.cpp
index 418ea49..5714878 100644
--- a/qmake/tools/qdir.cpp
+++ b/qmake/tools/qdir.cpp
@@ -1,1294 +1,1342 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QDir class
 **
 ** Created : 950427
 **
-** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
+** Copyright (C) 1992-2003 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qplatformdefs.h"
 #include "qdir.h"
 
 #ifndef QT_NO_DIR
 #include <private/qdir_p.h>
 #include "qfileinfo.h"
 #include "qregexp.h"
 #include "qstringlist.h"
-#include <stdlib.h>
-#include <ctype.h>
+#include <limits.h>
 
+#if defined(Q_FS_FAT) && !defined(Q_OS_UNIX)
+const bool CaseSensitiveFS = FALSE;
+#else
+const bool CaseSensitiveFS = TRUE;
+#endif
 
 
 /*!
     \class QDir
+    \reentrant
     \brief The QDir class provides access to directory structures and their contents in a platform-independent way.
 
     \ingroup io
     \mainclass
 
     A QDir is used to manipulate path names, access information
     regarding paths and files, and manipulate the underlying file
     system.
 
     A QDir can point to a file using either a relative or an absolute
     path. Absolute paths begin with the directory separator "/"
     (optionally preceded by a drive specification under Windows). If
     you always use "/" as a directory separator, Qt will translate
     your paths to conform to the underlying operating system. Relative
     file names begin with a directory name or a file name and specify
     a path relative to the current directory.
 
     The "current" path refers to the application's working directory.
     A QDir's own path is set and retrieved with setPath() and path().
 
     An example of an absolute path is the string "/tmp/quartz", a
     relative path might look like "src/fatlib". You can use the
     function isRelative() to check if a QDir is using a relative or an
     absolute file path. Call convertToAbs() to convert a relative QDir
     to an absolute one. For a simplified path use cleanDirPath(). To
     obtain a path which has no symbolic links or redundant ".."
     elements use canonicalPath(). The path can be set with setPath(),
     and changed with cd() and cdUp().
 
     QDir provides several static functions, for example, setCurrent()
     to set the application's working directory and currentDirPath() to
     retrieve the application's working directory. Access to some
     common paths is provided with the static functions, current(),
     home() and root() which return QDir objects or currentDirPath(),
     homeDirPath() and rootDirPath() which return the path as a string.
 
     The number of entries in a directory is returned by count().
     Obtain a string list of the names of all the files and directories
     in a directory with entryList(). If you prefer a list of QFileInfo
     pointers use entryInfoList(). Both these functions can apply a
     name filter, an attributes filter (e.g. read-only, files not
     directories, etc.), and a sort order. The filters and sort may be
     set with calls to setNameFilter(), setFilter() and setSorting().
     They may also be specified in the entryList() and
     entryInfoList()'s arguments.
 
     Create a new directory with mkdir(), rename a directory with
     rename() and remove an existing directory with rmdir(). Remove a
     file with remove(). You can interrogate a directory with exists(),
     isReadable() and isRoot().
 
     To get a path with a filename use filePath(), and to get a
     directory name use dirName(); neither of these functions checks
     for the existence of the file or directory.
 
     The list of root directories is provided by drives(); on Unix
     systems this returns a list containing one root directory, "/"; on
     Windows the list will usually contain "C:/", and possibly "D:/",
     etc.
 
     If you need the path in a form suitable for the underlying
     operating system use convertSeparators().
 
     Examples:
 
     See if a directory exists.
     \code
     QDir d( "example" );			// "./example"
     if ( !d.exists() )
 	qWarning( "Cannot find the example directory" );
     \endcode
 
     Traversing directories and reading a file.
     \code
     QDir d = QDir::root();			// "/"
     if ( !d.cd("tmp") ) {			// "/tmp"
 	qWarning( "Cannot find the \"/tmp\" directory" );
     } else {
 	QFile f( d.filePath("ex1.txt") );	// "/tmp/ex1.txt"
 	if ( !f.open(IO_ReadWrite) )
 	    qWarning( "Cannot create the file %s", f.name() );
     }
     \endcode
 
     A program that lists all the files in the current directory
     (excluding symbolic links), sorted by size, smallest first:
     \code
     #include <stdio.h>
     #include <qdir.h>
 
     int main( int argc, char **argv )
     {
 	QDir d;
 	d.setFilter( QDir::Files | QDir::Hidden | QDir::NoSymLinks );
 	d.setSorting( QDir::Size | QDir::Reversed );
 
 	const QFileInfoList *list = d.entryInfoList();
 	QFileInfoListIterator it( *list );
 	QFileInfo *fi;
 
 	printf( "     Bytes Filename\n" );
 	while ( (fi = it.current()) != 0 ) {
 	    printf( "%10li %s\n", fi->size(), fi->fileName().latin1() );
 	    ++it;
 	}
 	return 0;
     }
     \endcode
 */
 
 /*!
     Constructs a QDir pointing to the current directory.
 
     \sa currentDirPath()
 */
 
 QDir::QDir()
 {
     dPath = QString::fromLatin1(".");
     init();
 }
 
 /*!
     Constructs a QDir with path \a path, that filters its entries by
     name using \a nameFilter and by attributes using \a filterSpec. It
     also sorts the names using \a sortSpec.
 
     The default \a nameFilter is an empty string, which excludes
     nothing; the default \a filterSpec is \c All, which also means
     exclude nothing. The default \a sortSpec is \c Name|IgnoreCase,
     i.e. sort by name case-insensitively.
 
     Example that lists all the files in "/tmp":
     \code
     QDir d( "/tmp" );
     for ( int i = 0; i < d.count(); i++ )
 	printf( "%s\n", d[i] );
     \endcode
 
     If \a path is "" or QString::null, QDir uses "." (the current
     directory). If \a nameFilter is "" or QString::null, QDir uses the
     name filter "*" (all files).
 
     Note that \a path need not exist.
 
     \sa exists(), setPath(), setNameFilter(), setFilter(), setSorting()
 */
 
 QDir::QDir( const QString &path, const QString &nameFilter,
 	    int sortSpec, int filterSpec )
 {
     init();
     dPath = cleanDirPath( path );
     if ( dPath.isEmpty() )
 	dPath = QString::fromLatin1(".");
     nameFilt = nameFilter;
     if ( nameFilt.isEmpty() )
 	nameFilt = QString::fromLatin1("*");
     filtS = (FilterSpec)filterSpec;
     sortS = (SortSpec)sortSpec;
 }
 
 /*!
     Constructs a QDir that is a copy of the directory \a d.
 
     \sa operator=()
 */
 
 QDir::QDir( const QDir &d )
 {
     dPath = d.dPath;
     fList = 0;
     fiList = 0;
     nameFilt = d.nameFilt;
     dirty = TRUE;
     allDirs = d.allDirs;
     filtS = d.filtS;
     sortS = d.sortS;
 }
 
+/*!
+    Refreshes the directory information.
+*/
+void QDir::refresh() const
+{
+    QDir* that = (QDir*) this;
+    that->dirty = TRUE;
+}
 
 void QDir::init()
 {
     fList = 0;
     fiList = 0;
     nameFilt = QString::fromLatin1("*");
     dirty = TRUE;
     allDirs = FALSE;
     filtS = All;
     sortS = SortSpec(Name | IgnoreCase);
 }
 
 /*!
     Destroys the QDir frees up its resources.
 */
 
 QDir::~QDir()
 {
     delete fList;
     delete fiList;
 }
 
 
 /*!
     Sets the path of the directory to \a path. The path is cleaned of
     redundant ".", ".." and of multiple separators. No check is made
     to ensure that a directory with this path exists.
 
     The path can be either absolute or relative. Absolute paths begin
     with the directory separator "/" (optionally preceded by a drive
     specification under Windows). Relative file names begin with a
     directory name or a file name and specify a path relative to the
     current directory. An example of an absolute path is the string
     "/tmp/quartz", a relative path might look like "src/fatlib".
 
     \sa path(), absPath(), exists(), cleanDirPath(), dirName(),
       absFilePath(), isRelative(), convertToAbs()
 */
 
 void QDir::setPath( const QString &path )
 {
     dPath = cleanDirPath( path );
     if ( dPath.isEmpty() )
 	dPath = QString::fromLatin1(".");
     dirty = TRUE;
 }
 
 /*!
     \fn  QString QDir::path() const
 
     Returns the path, this may contain symbolic links, but never
     contains redundant ".", ".." or multiple separators.
 
     The returned path can be either absolute or relative (see
     setPath()).
 
     \sa setPath(), absPath(), exists(), cleanDirPath(), dirName(),
     absFilePath(), convertSeparators()
 */
 
 /*!
     Returns the absolute path (a path that starts with "/" or with a
     drive specification), which may contain symbolic links, but never
     contains redundant ".", ".." or multiple separators.
 
     \sa setPath(), canonicalPath(), exists(),  cleanDirPath(),
     dirName(), absFilePath()
 */
 
 QString QDir::absPath() const
 {
     if ( QDir::isRelativePath(dPath) ) {
 	QString tmp = currentDirPath();
 	if ( tmp.right(1) != QString::fromLatin1("/") )
 	    tmp += '/';
 	tmp += dPath;
 	return cleanDirPath( tmp );
     } else {
 	return cleanDirPath( dPath );
     }
 }
 
 /*!
     Returns the name of the directory; this is \e not the same as the
     path, e.g. a directory with the name "mail", might have the path
     "/var/spool/mail". If the directory has no name (e.g. it is the
     root directory) QString::null is returned.
 
     No check is made to ensure that a directory with this name
     actually exists.
 
     \sa path(), absPath(), absFilePath(), exists(), QString::isNull()
 */
 
 QString QDir::dirName() const
 {
     int pos = dPath.findRev( '/' );
     if ( pos == -1  )
 	return dPath;
     return dPath.right( dPath.length() - pos - 1 );
 }
 
 /*!
     Returns the path name of a file in the directory. Does \e not
     check if the file actually exists in the directory. If the QDir is
     relative the returned path name will also be relative. Redundant
     multiple separators or "." and ".." directories in \a fileName
     will not be removed (see cleanDirPath()).
 
     If \a acceptAbsPath is TRUE a \a fileName starting with a
     separator "/" will be returned without change. If \a acceptAbsPath
     is FALSE an absolute path will be prepended to the fileName and
     the resultant string returned.
 
     \sa absFilePath(), isRelative(), canonicalPath()
 */
 
 QString QDir::filePath( const QString &fileName,
 			bool acceptAbsPath ) const
 {
     if ( acceptAbsPath && !isRelativePath(fileName) )
 	return QString(fileName);
 
     QString tmp = dPath;
     if ( tmp.isEmpty() || (tmp[(int)tmp.length()-1] != '/' && !!fileName &&
 			   fileName[0] != '/') )
 	tmp += '/';
     tmp += fileName;
     return tmp;
 }
 
 /*!
     Returns the absolute path name of a file in the directory. Does \e
     not check if the file actually exists in the directory. Redundant
     multiple separators or "." and ".." directories in \a fileName
     will not be removed (see cleanDirPath()).
 
     If \a acceptAbsPath is TRUE a \a fileName starting with a
     separator "/" will be returned without change. If \a acceptAbsPath
     is FALSE an absolute path will be prepended to the fileName and
     the resultant string returned.
 
     \sa filePath()
 */
 
 QString QDir::absFilePath( const QString &fileName,
 			   bool acceptAbsPath ) const
 {
     if ( acceptAbsPath && !isRelativePath( fileName ) )
 	return fileName;
 
     QString tmp = absPath();
-    if ( tmp.isEmpty() || (tmp[(int)tmp.length()-1] != '/' && !!fileName &&
-			   fileName[0] != '/') )
-	tmp += '/';
-    tmp += fileName;
+#ifdef Q_OS_WIN32
+    if ( fileName[0].isLetter() && fileName[1] == ':' ) {
+	int drv = fileName.upper()[0].latin1() - 'A' + 1;
+	if ( _getdrive() != drv ) {
+	    if ( qt_winunicode ) {
+		TCHAR buf[PATH_MAX];
+		::_tgetdcwd( drv, buf, PATH_MAX );
+		tmp.setUnicodeCodes( (ushort*)buf, ::_tcslen(buf) );
+	    } else {
+		char buf[PATH_MAX];
+		::_getdcwd( drv, buf, PATH_MAX );
+		tmp = buf;
+	    }
+	    if ( !tmp.endsWith("\\") )
+		tmp += "\\";
+	    tmp += fileName.right( fileName.length() - 2 );
+	    int x;
+	    for ( x = 0; x < (int) tmp.length(); x++ ) {
+		if ( tmp[x] == '\\' )
+		    tmp[x] = '/';
+	    }
+	}
+    } else
+#endif
+    {
+	if ( tmp.isEmpty() || (tmp[(int)tmp.length()-1] != '/' && !!fileName &&
+			       fileName[0] != '/') )
+	    tmp += '/';
+	tmp += fileName;
+    }
     return tmp;
 }
 
 
 /*!
     Returns \a pathName with the '/' separators converted to
     separators that are appropriate for the underlying operating
     system.
 
     On Windows, convertSeparators("c:/winnt/system32") returns
     "c:\winnt\system32".
 
     The returned string may be the same as the argument on some
     operating systems, for example on Unix.
 */
 
 QString QDir::convertSeparators( const QString &pathName )
 {
     QString n( pathName );
 #if defined(Q_FS_FAT) || defined(Q_OS_OS2EMX)
     for ( int i=0; i<(int)n.length(); i++ ) {
 	if ( n[i] == '/' )
 	    n[i] = '\\';
     }
 #elif defined(Q_OS_MAC9)
 	while(n.length() && n[0] == '/' ) n = n.right(n.length()-1);
     for ( int i=0; i<(int)n.length(); i++ ) {
 	if ( n[i] == '/' )
 	    n[i] = ':';
     }
     if(n.contains(':') && n.left(1) != ':')
 	n.prepend(':');
 #endif
     return n;
 }
 
 
 /*!
     Changes the QDir's directory to \a dirName.
 
     If \a acceptAbsPath is TRUE a path starting with separator "/"
     will cause the function to change to the absolute directory. If \a
     acceptAbsPath is FALSE any number of separators at the beginning
     of \a dirName will be removed and the function will descend into
     \a dirName.
 
     Returns TRUE if the new directory exists and is readable;
     otherwise returns FALSE. Note that the logical cd() operation is
     not performed if the new directory does not exist.
 
     Calling cd( ".." ) is equivalent to calling cdUp().
 
     \sa cdUp(), isReadable(), exists(), path()
 */
 
 bool QDir::cd( const QString &dirName, bool acceptAbsPath )
 {
     if ( dirName.isEmpty() || dirName==QString::fromLatin1(".") )
 	return TRUE;
     QString old = dPath;
     if ( acceptAbsPath && !isRelativePath(dirName) ) {
 	dPath = cleanDirPath( dirName );
     } else {
 	if ( !isRoot() ) {
 	    dPath += '/';
 	} else if ( dirName == ".." ) {
 	    dPath = old;
 	    return FALSE;
 	}
 	dPath += dirName;
 	if ( dirName.find('/') >= 0
 		|| old == QString::fromLatin1(".")
 		|| dirName == QString::fromLatin1("..") )
 	    dPath = cleanDirPath( dPath );
     }
     if ( !exists() ) {
 	dPath = old;			// regret
 	return FALSE;
     }
     dirty = TRUE;
     return TRUE;
 }
 
 /*!
     Changes directory by moving one directory up from the QDir's
     current directory.
 
     Returns TRUE if the new directory exists and is readable;
     otherwise returns FALSE. Note that the logical cdUp() operation is
     not performed if the new directory does not exist.
 
     \sa cd(), isReadable(), exists(), path()
 */
 
 bool QDir::cdUp()
 {
     return cd( QString::fromLatin1("..") );
 }
 
 /*!
     \fn QString QDir::nameFilter() const
 
     Returns the string set by setNameFilter()
 */
 
 /*!
     Sets the name filter used by entryList() and entryInfoList() to \a
     nameFilter.
 
     The \a nameFilter is a wildcard (globbing) filter that understands
     "*" and "?" wildcards. (See \link qregexp.html#wildcard-matching
     QRegExp wildcard matching\endlink.) You may specify several filter
     entries all separated by a single space " " or by a semi-colon
     ";".
 
     For example, if you want entryList() and entryInfoList() to list
     all files ending with either ".cpp" or ".h", you would use either
     dir.setNameFilter("*.cpp *.h") or dir.setNameFilter("*.cpp;*.h").
 
     \sa nameFilter(), setFilter()
 */
 
 void QDir::setNameFilter( const QString &nameFilter )
 {
     nameFilt = nameFilter;
     if ( nameFilt.isEmpty() )
 	nameFilt = QString::fromLatin1("*");
     dirty = TRUE;
 }
 
 /*!
     \fn QDir::FilterSpec QDir::filter() const
 
     Returns the value set by setFilter()
 */
 
 /*!
     \enum QDir::FilterSpec
 
     This enum describes the filtering options available to QDir, e.g.
     for entryList() and entryInfoList(). The filter value is specified
     by OR-ing together values from the following list:
 
     \value Dirs  List directories only.
     \value Files  List files only.
     \value  Drives  List disk drives (ignored under Unix).
     \value  NoSymLinks  Do not list symbolic links (ignored by operating
     systems that don't support symbolic links).
     \value All List directories, files, drives and symlinks (this does not list
     broken symlinks unless you specify System).
     \value TypeMask A mask for the the Dirs, Files, Drives and
     NoSymLinks flags.
     \value  Readable  List files for which the application has read access.
     \value  Writable  List files for which the application has write access.
     \value  Executable  List files for which the application has execute
     access. Executables needs to be combined with Dirs or Files.
     \value  RWEMask A mask for the Readable, Writable and Executable flags.
     \value  Modified  Only list files that have been modified (ignored
     under Unix).
     \value  Hidden  List hidden files (on Unix, files starting with a .).
     \value  System  List system files (on Unix, FIFOs, sockets and
     device files)
     \value AccessMask A mask for the Readable, Writable, Executable
     Modified, Hidden and System flags
     \value DefaultFilter Internal flag.
 
     If you do not set any of \c Readable, \c Writable or \c
     Executable, QDir will set all three of them. This makes the
     default easy to write and at the same time useful.
 
     Examples: \c Readable|Writable means list all files for which the
     application has read access, write access or both. \c Dirs|Drives
     means list drives, directories, all files that the application can
     read, write or execute, and also symlinks to such
     files/directories.
 */
 
 
 /*!
     Sets the filter used by entryList() and entryInfoList() to \a
     filterSpec. The filter is used to specify the kind of files that
     should be returned by entryList() and entryInfoList(). See
     \l{QDir::FilterSpec}.
 
     \sa filter(), setNameFilter()
 */
 
 void QDir::setFilter( int filterSpec )
 {
     if ( filtS == (FilterSpec) filterSpec )
 	return;
     filtS = (FilterSpec) filterSpec;
     dirty = TRUE;
 }
 
 /*!
     \fn QDir::SortSpec QDir::sorting() const
 
     Returns the value set by setSorting()
 
     \sa setSorting() SortSpec
 */
 
 /*!
     \enum QDir::SortSpec
 
     This enum describes the sort options available to QDir, e.g. for
     entryList() and entryInfoList(). The sort value is specified by
     OR-ing together values from the following list:
 
     \value Name  Sort by name.
     \value Time  Sort by time (modification time).
     \value Size  Sort by file size.
     \value Unsorted  Do not sort.
     \value SortByMask A mask for Name, Time and Size.
 
     \value DirsFirst  Put the directories first, then the files.
     \value Reversed  Reverse the sort order.
     \value IgnoreCase  Sort case-insensitively.
     \value DefaultSort Internal flag.
 
     You can only specify one of the first four.
 
     If you specify both \c DirsFirst and \c Reversed, directories are
     still put first, but in reverse order; the files will be listed
     after the directories, again in reverse order.
 */
 
 // ### Unsorted+DirsFirst ? Unsorted+Reversed?
 
 /*!
     Sets the sort order used by entryList() and entryInfoList().
 
     The \a sortSpec is specified by OR-ing values from the enum
     \l{QDir::SortSpec}.
 
     \sa sorting() SortSpec
 */
 
 void QDir::setSorting( int sortSpec )
 {
     if ( sortS == (SortSpec) sortSpec )
 	return;
     sortS = (SortSpec) sortSpec;
     dirty = TRUE;
 }
 
 /*!
     \fn bool QDir::matchAllDirs() const
 
     Returns the value set by setMatchAllDirs()
 
     \sa setMatchAllDirs()
 */
 
 /*!
     If \a enable is TRUE then all directories are included (e.g. in
     entryList()), and the nameFilter() is only applied to the files.
     If \a enable is FALSE then the nameFilter() is applied to both
     directories and files.
 
     \sa matchAllDirs()
 */
 
 void QDir::setMatchAllDirs( bool enable )
 {
     if ( (bool)allDirs == enable )
 	return;
     allDirs = enable;
     dirty = TRUE;
 }
 
 
 /*!
     Returns the total number of directories and files that were found.
 
     Equivalent to entryList().count().
 
     \sa operator[](), entryList()
 */
 
 uint QDir::count() const
 {
     return (uint)entryList().count();
 }
 
 /*!
     Returns the file name at position \a index in the list of file
     names. Equivalent to entryList().at(index).
 
     Returns a QString::null if the \a index is out of range or if the
     entryList() function failed.
 
     \sa count(), entryList()
 */
 
 QString QDir::operator[]( int index ) const
 {
     entryList();
     return fList && index >= 0 && index < (int)fList->count() ?
 	(*fList)[index] : QString::null;
 }
 
 
 /*!
     \obsolete
   This function is included to easy porting from Qt 1.x to Qt 2.0,
   it is the same as entryList(), but encodes the filenames as 8-bit
   strings using QFile::encodedName().
 
   It is more efficient to use entryList().
 */
 QStrList QDir::encodedEntryList( int filterSpec, int sortSpec ) const
 {
     QStrList r;
     QStringList l = entryList(filterSpec,sortSpec);
     for ( QStringList::Iterator it = l.begin(); it != l.end(); ++it ) {
 	r.append( QFile::encodeName(*it) );
     }
     return r;
 }
 
 /*!
     \obsolete
     \overload
   This function is included to easy porting from Qt 1.x to Qt 2.0,
   it is the same as entryList(), but encodes the filenames as 8-bit
   strings using QFile::encodedName().
 
   It is more efficient to use entryList().
 */
 QStrList QDir::encodedEntryList( const QString &nameFilter,
 			   int filterSpec,
 			   int sortSpec ) const
 {
     QStrList r;
     QStringList l = entryList(nameFilter,filterSpec,sortSpec);
     for ( QStringList::Iterator it = l.begin(); it != l.end(); ++it ) {
 	r.append( QFile::encodeName(*it) );
     }
     return r;
 }
 
 
 
 /*!
     \overload
 
     Returns a list of the names of all the files and directories in
     the directory, ordered in accordance with setSorting() and
     filtered in accordance with setFilter() and setNameFilter().
 
     The filter and sorting specifications can be overridden using the
     \a filterSpec and \a sortSpec arguments.
 
     Returns an empty list if the directory is unreadable or does not
     exist.
 
     \sa entryInfoList(), setNameFilter(), setSorting(), setFilter()
 */
 
 QStringList QDir::entryList( int filterSpec, int sortSpec ) const
 {
     if ( !dirty && filterSpec == (int)DefaultFilter &&
 		   sortSpec   == (int)DefaultSort )
 	return *fList;
     return entryList( nameFilt, filterSpec, sortSpec );
 }
 
 /*!
     Returns a list of the names of all the files and directories in
     the directory, ordered in accordance with setSorting() and
     filtered in accordance with setFilter() and setNameFilter().
 
     The filter and sorting specifications can be overridden using the
     \a nameFilter, \a filterSpec and \a sortSpec arguments.
 
     Returns an empty list if the directory is unreadable or does not
     exist.
 
     \sa entryInfoList(), setNameFilter(), setSorting(), setFilter()
 */
 
 QStringList QDir::entryList( const QString &nameFilter,
 				 int filterSpec, int sortSpec ) const
 {
     if ( filterSpec == (int)DefaultFilter )
 	filterSpec = filtS;
     if ( sortSpec == (int)DefaultSort )
 	sortSpec = sortS;
     QDir *that = (QDir*)this;			// mutable function
     if ( that->readDirEntries(nameFilter, filterSpec, sortSpec) ) {
 	if ( that->fList )
 	    return *that->fList;
     }
     return QStringList();
 }
 
 /*!
     \overload
 
     Returns a list of QFileInfo objects for all the files and
     directories in the directory, ordered in accordance with
     setSorting() and filtered in accordance with setFilter() and
     setNameFilter().
 
     The filter and sorting specifications can be overridden using the
     \a filterSpec and \a sortSpec arguments.
 
     Returns 0 if the directory is unreadable or does not exist.
 
     The returned pointer is a const pointer to a QFileInfoList. The
     list is owned by the QDir object and will be reused on the next
     call to entryInfoList() for the same QDir instance. If you want to
     keep the entries of the list after a subsequent call to this
     function you must copy them.
 
     \sa entryList(), setNameFilter(), setSorting(), setFilter()
 */
 
 const QFileInfoList *QDir::entryInfoList( int filterSpec, int sortSpec ) const
 {
     if ( !dirty && filterSpec == (int)DefaultFilter &&
 		   sortSpec   == (int)DefaultSort )
 	return fiList;
     return entryInfoList( nameFilt, filterSpec, sortSpec );
 }
 
 /*!
     Returns a list of QFileInfo objects for all the files and
     directories in the directory, ordered in accordance with
     setSorting() and filtered in accordance with setFilter() and
     setNameFilter().
 
     The filter and sorting specifications can be overridden using the
     \a nameFilter, \a filterSpec and \a sortSpec arguments.
 
     Returns 0 if the directory is unreadable or does not exist.
 
     The returned pointer is a const pointer to a QFileInfoList. The
     list is owned by the QDir object and will be reused on the next
     call to entryInfoList() for the same QDir instance. If you want to
     keep the entries of the list after a subsequent call to this
     function you must copy them.
 
     \sa entryList(), setNameFilter(), setSorting(), setFilter()
 */
 
 const QFileInfoList *QDir::entryInfoList( const QString &nameFilter,
 					  int filterSpec, int sortSpec ) const
 {
     if ( filterSpec == (int)DefaultFilter )
 	filterSpec = filtS;
     if ( sortSpec == (int)DefaultSort )
 	sortSpec = sortS;
     QDir *that = (QDir*)this;			// mutable function
     if ( that->readDirEntries(nameFilter, filterSpec, sortSpec) )
 	return that->fiList;
     else
 	return 0;
 }
 
 /*!
     \overload
 
     Returns TRUE if the \e directory exists; otherwise returns FALSE.
     (If a file with the same name is found this function will return
     FALSE).
 
     \sa QFileInfo::exists(), QFile::exists()
 */
 
 bool QDir::exists() const
 {
     QFileInfo fi( dPath );
     return fi.exists() && fi.isDir();
 }
 
 /*!
     Returns TRUE if the directory path is relative to the current
     directory and returns FALSE if the path is absolute (e.g. under
     UNIX a path is relative if it does not start with a "/").
 
     \sa convertToAbs()
 */
 
 bool QDir::isRelative() const
 {
     return isRelativePath( dPath );
 }
 
 /*!
     Converts the directory path to an absolute path. If it is already
     absolute nothing is done.
 
     \sa isRelative()
 */
 
 void QDir::convertToAbs()
 {
     dPath = absPath();
 }
 
 /*!
     Makes a copy of QDir \a d and assigns it to this QDir.
 */
 
 QDir &QDir::operator=( const QDir &d )
 {
     dPath    = d.dPath;
     delete fList;
     fList    = 0;
     delete fiList;
     fiList   = 0;
     nameFilt = d.nameFilt;
     dirty    = TRUE;
     allDirs  = d.allDirs;
     filtS    = d.filtS;
     sortS    = d.sortS;
     return *this;
 }
 
 /*!
     \overload
 
     Sets the directory path to be the given \a path.
 */
 
 QDir &QDir::operator=( const QString &path )
 {
     dPath = cleanDirPath( path );
     dirty = TRUE;
     return *this;
 }
 
 
 /*!
     \fn bool QDir::operator!=( const QDir &d ) const
 
     Returns TRUE if directory \a d and this directory have different
     paths or different sort or filter settings; otherwise returns
     FALSE.
 
     Example:
     \code
     // The current directory is "/usr/local"
     QDir d1( "/usr/local/bin" );
     QDir d2( "bin" );
-    if ( d1 != d2 ) qDebug( "They differ\n" ); // This is printed
+    if ( d1 != d2 )
+	qDebug( "They differ" );
     \endcode
 */
 
 /*!
     Returns TRUE if directory \a d and this directory have the same
     path and their sort and filter settings are the same; otherwise
     returns FALSE.
 
     Example:
     \code
     // The current directory is "/usr/local"
     QDir d1( "/usr/local/bin" );
     QDir d2( "bin" );
     d2.convertToAbs();
-    if ( d1 == d2 ) qDebug( "They're the same\n" ); // This is printed
+    if ( d1 == d2 )
+	qDebug( "They're the same" );
     \endcode
 */
 
 bool QDir::operator==( const QDir &d ) const
 {
     return dPath    == d.dPath &&
 	   nameFilt == d.nameFilt &&
 	   allDirs  == d.allDirs &&
 	   filtS    == d.filtS &&
 	   sortS    == d.sortS;
 }
 
 
 /*!
     Removes the file, \a fileName.
 
     If \a acceptAbsPath is TRUE a path starting with separator "/"
     will remove the file with the absolute path. If \a acceptAbsPath
     is FALSE any number of separators at the beginning of \a fileName
     will be removed and the resultant file name will be removed.
 
     Returns TRUE if the file is removed successfully; otherwise
     returns FALSE.
 */
 
 bool QDir::remove( const QString &fileName, bool acceptAbsPath )
 {
     if ( fileName.isEmpty() ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QDir::remove: Empty or null file name" );
 #endif
 	return FALSE;
     }
     QString p = filePath( fileName, acceptAbsPath );
     return QFile::remove( p );
 }
 
 /*!
     Checks for the existence of the file \a name.
 
     If \a acceptAbsPath is TRUE a path starting with separator "/"
     will check the file with the absolute path. If \a acceptAbsPath is
     FALSE any number of separators at the beginning of \a name will be
     removed and the resultant file name will be checked.
 
     Returns TRUE if the file exists; otherwise returns FALSE.
 
     \sa QFileInfo::exists(), QFile::exists()
 */
 
 bool QDir::exists( const QString &name, bool acceptAbsPath ) //### const in 4.0
 {
     if ( name.isEmpty() ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QDir::exists: Empty or null file name" );
 #endif
 	return FALSE;
     }
     QString tmp = filePath( name, acceptAbsPath );
     return QFile::exists( tmp );
 }
 
 /*!
     Returns the native directory separator; "/" under UNIX (including
     Mac OS X) and "\" under Windows.
 
     You do not need to use this function to build file paths. If you
     always use "/", Qt will translate your paths to conform to the
     underlying operating system.
 */
 
 char QDir::separator()
 {
 #if defined(Q_OS_UNIX)
     return '/';
 #elif defined (Q_FS_FAT) || defined(Q_WS_WIN)
     return '\\';
 #elif defined (Q_OS_MAC)
     return ':';
 #else
     return '/';
 #endif
 }
 
 /*!
     Returns the application's current directory.
 
     Use path() to access a QDir object's path.
 
     \sa currentDirPath(), QDir::QDir()
 */
 
 QDir QDir::current()
 {
     return QDir( currentDirPath() );
 }
 
 /*!
     Returns the home directory.
 
     Under Windows the \c HOME environment variable is used. If this
     does not exist the \c USERPROFILE environment variable is used. If
     that does not exist the path is formed by concatenating the \c
     HOMEDRIVE and \c HOMEPATH environment variables. If they don't
     exist the rootDirPath() is used (this uses the \c SystemDrive
     environment variable). If none of these exist "C:\" is used.
 
     Under non-Windows operating systems the \c HOME environment
     variable is used if it exists, otherwise rootDirPath() is used.
 
     \sa homeDirPath()
 */
 
 QDir QDir::home()
 {
     return QDir( homeDirPath() );
 }
 
 /*!
     Returns the root directory.
 
     \sa rootDirPath() drives()
 */
 
 QDir QDir::root()
 {
     return QDir( rootDirPath() );
 }
 
 /*!
     \fn QString QDir::homeDirPath()
 
     Returns the absolute path of the user's home directory.
 
     \sa home()
 */
 
-QStringList qt_makeFilterList( const QString &filter )
+QValueList<QRegExp> qt_makeFilterList( const QString &filter )
 {
+    QValueList<QRegExp> regExps;
     if ( filter.isEmpty() )
-	return QStringList();
+	return regExps;
 
     QChar sep( ';' );
     int i = filter.find( sep, 0 );
     if ( i == -1 && filter.find( ' ', 0 ) != -1 )
 	sep = QChar( ' ' );
 
     QStringList list = QStringList::split( sep, filter );
     QStringList::Iterator it = list.begin();
-    QStringList list2;
+    while ( it != list.end() ) {
+	regExps << QRegExp( (*it).stripWhiteSpace(), CaseSensitiveFS, TRUE );
+	++it;
+    }
+    return regExps;
+}
 
-    for ( ; it != list.end(); ++it ) {
-	QString s = *it;
-	list2 << s.stripWhiteSpace();
+bool qt_matchFilterList( const QValueList<QRegExp>& filters,
+			 const QString &fileName )
+{
+    QValueList<QRegExp>::ConstIterator rit = filters.begin();
+    while ( rit != filters.end() ) {
+	if ( (*rit).exactMatch(fileName) )
+	    return TRUE;
+	++rit;
     }
-    return list2;
+    return FALSE;
 }
 
+
 /*!
     \overload
 
     Returns TRUE if the \a fileName matches any of the wildcard (glob)
     patterns in the list of \a filters; otherwise returns FALSE.
 
     (See \link qregexp.html#wildcard-matching QRegExp wildcard
     matching.\endlink)
     \sa QRegExp::match()
 */
 
 bool QDir::match( const QStringList &filters, const QString &fileName )
 {
     QStringList::ConstIterator sit = filters.begin();
     while ( sit != filters.end() ) {
-#if defined(Q_FS_FAT) && !defined(Q_OS_UNIX)
-	QRegExp rx( *sit, FALSE, TRUE ); // The FAT FS is not case sensitive..
-#else
-	QRegExp rx( *sit, TRUE, TRUE );  // ..while others are.
-#endif
+	QRegExp rx( *sit, CaseSensitiveFS, TRUE );
 	if ( rx.exactMatch(fileName) )
 	    return TRUE;
 	++sit;
     }
     return FALSE;
 }
 
 /*!
     Returns TRUE if the \a fileName matches the wildcard (glob)
     pattern \a filter; otherwise returns FALSE. The \a filter may
     contain multiple patterns separated by spaces or semicolons.
 
     (See \link qregexp.html#wildcard-matching QRegExp wildcard
     matching.\endlink)
     \sa QRegExp::match()
 */
 
 bool QDir::match( const QString &filter, const QString &fileName )
 {
-    QStringList lst = qt_makeFilterList( filter );
-    return match( lst, fileName );
+    return qt_matchFilterList( qt_makeFilterList(filter), fileName );
 }
 
 
 /*!
     Removes all multiple directory separators "/" and resolves any
     "."s or ".."s found in the path, \a filePath.
 
     Symbolic links are kept. This function does not return the
     canonical path, but rather the simplest version of the input.
     For example, "./local" becomes "local", "local/../bin" becomes
     "bin" and "/local/usr/../bin" becomes "/local/bin".
 
     \sa absPath() canonicalPath()
 */
 
 QString QDir::cleanDirPath( const QString &filePath )
 {
     QString name = filePath;
     QString newPath;
 
     if ( name.isEmpty() )
 	return name;
 
     slashify( name );
 
     bool addedSeparator;
     if ( isRelativePath(name) ) {
 	addedSeparator = TRUE;
 	name.insert( 0, '/' );
     } else {
 	addedSeparator = FALSE;
     }
 
     int ePos, pos, upLevel;
 
     pos = ePos = name.length();
     upLevel = 0;
     int len;
 
     while ( pos && (pos = name.findRev('/',--pos)) != -1 ) {
 	len = ePos - pos - 1;
 	if ( len == 2 && name.at(pos + 1) == '.'
 		      && name.at(pos + 2) == '.' ) {
 	    upLevel++;
 	} else {
 	    if ( len != 0 && (len != 1 || name.at(pos + 1) != '.') ) {
 		if ( !upLevel )
 		    newPath = QString::fromLatin1("/")
 			+ name.mid(pos + 1, len) + newPath;
 		else
 		    upLevel--;
 	    }
 	}
 	ePos = pos;
     }
     if ( addedSeparator ) {
 	while ( upLevel-- )
 	    newPath.insert( 0, QString::fromLatin1("/..") );
 	if ( !newPath.isEmpty() )
 	    newPath.remove( 0, 1 );
 	else
 	    newPath = QString::fromLatin1(".");
     } else {
 	if ( newPath.isEmpty() )
 	    newPath = QString::fromLatin1("/");
 #if defined(Q_FS_FAT) || defined(Q_OS_OS2EMX)
 	if ( name[0] == '/' ) {
 	    if ( name[1] == '/' )		// "\\machine\x\ ..."
 		newPath.insert( 0, '/' );
 	} else {
 	    newPath = name.left(2) + newPath;
 	}
 #endif
     }
     return newPath;
 }
 
 int qt_cmp_si_sortSpec;
 
 #if defined(Q_C_CALLBACKS)
 extern "C" {
 #endif
 
 #ifdef Q_OS_TEMP
 int __cdecl qt_cmp_si( const void *n1, const void *n2 )
 #else
 int qt_cmp_si( const void *n1, const void *n2 )
 #endif
 {
     if ( !n1 || !n2 )
 	return 0;
 
     QDirSortItem* f1 = (QDirSortItem*)n1;
     QDirSortItem* f2 = (QDirSortItem*)n2;
 
     if ( qt_cmp_si_sortSpec & QDir::DirsFirst )
 	if ( f1->item->isDir() != f2->item->isDir() )
 	    return f1->item->isDir() ? -1 : 1;
 
     int r = 0;
     int sortBy = qt_cmp_si_sortSpec & QDir::SortByMask;
 
     switch ( sortBy ) {
       case QDir::Time:
 	r = f1->item->lastModified().secsTo(f2->item->lastModified());
 	break;
       case QDir::Size:
 	r = f2->item->size() - f1->item->size();
 	break;
       default:
 	;
     }
 
     if ( r == 0 && sortBy != QDir::Unsorted ) {
 	// Still not sorted - sort by name
 	bool ic = qt_cmp_si_sortSpec & QDir::IgnoreCase;
 
 	if ( f1->filename_cache.isNull() )
 	    f1->filename_cache = ic ? f1->item->fileName().lower()
 				    : f1->item->fileName();
 	if ( f2->filename_cache.isNull() )
 	    f2->filename_cache = ic ? f2->item->fileName().lower()
 				    : f2->item->fileName();
 
 	r = f1->filename_cache.compare(f2->filename_cache);
     }
 
     if ( r == 0 ) {
 	// Enforce an order - the order the items appear in the array
 	r = (char*)n1 - (char*)n2;
     }
 
     if ( qt_cmp_si_sortSpec & QDir::Reversed )
 	return -r;
     else
 	return r;
 }
 
 #if defined(Q_C_CALLBACKS)
 }
 #endif
 
 #endif // QT_NO_DIR
diff --git a/qmake/tools/qdir_unix.cpp b/qmake/tools/qdir_unix.cpp
index 57fe3c5..6a7adda 100644
--- a/qmake/tools/qdir_unix.cpp
+++ b/qmake/tools/qdir_unix.cpp
@@ -1,291 +1,297 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QDir class
 **
 ** Created : 950628
 **
-** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
+** Copyright (C) 1992-2003 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses for Unix/X11 or for Qt/Embedded may use this file in accordance
 ** with the Qt Commercial License Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qplatformdefs.h"
 #include "qdir.h"
 
 #ifndef QT_NO_DIR
 
 #include "qdir_p.h"
 #include "qfileinfo.h"
 #include "qregexp.h"
 #include "qstringlist.h"
 
 #ifdef QT_THREAD_SUPPORT
 #  include <private/qmutexpool_p.h>
 #endif // QT_THREAD_SUPPORT
 
 #include <stdlib.h>
 #include <limits.h>
+#include <errno.h>
 
 
 void QDir::slashify( QString& )
 {
 }
 
 QString QDir::homeDirPath()
 {
     QString d;
     d = QFile::decodeName(getenv("HOME"));
     slashify( d );
     if ( d.isNull() )
 	d = rootDirPath();
     return d;
 }
 
 QString QDir::canonicalPath() const
 {
     QString r;
-
     char cur[PATH_MAX+1];
-    if ( ::getcwd( cur, PATH_MAX ) )
-	if ( ::chdir(QFile::encodeName(dPath)) >= 0 ) {
-	    char tmp[PATH_MAX+1];
-	    if ( ::getcwd( tmp, PATH_MAX ) )
-		r = QFile::decodeName(tmp);
-	    ::chdir( cur );
-	}
-
-    slashify( r );
+    if ( ::getcwd( cur, PATH_MAX ) ) {
+	char tmp[PATH_MAX+1];
+	if( ::realpath( QFile::encodeName( dPath ), tmp ) )
+	    r = QFile::decodeName( tmp );
+	slashify( r );
+
+    	// always make sure we go back to the current dir
+	::chdir( cur );
+    }
     return r;
 }
 
 bool QDir::mkdir( const QString &dirName, bool acceptAbsPath ) const
 {
 #if defined(Q_OS_MACX)  // Mac X doesn't support trailing /'s
     QString name = dirName;
     if (dirName[dirName.length() - 1] == "/")
 	name = dirName.left( dirName.length() - 1 );
-    return ::mkdir( QFile::encodeName(filePath(name,acceptAbsPath)), 0777 )
-	== 0;
+    int status =
+	::mkdir( QFile::encodeName(filePath(name,acceptAbsPath)), 0777 );
 #else
-    return ::mkdir( QFile::encodeName(filePath(dirName,acceptAbsPath)), 0777 )
-	== 0;
+    int status =
+	::mkdir( QFile::encodeName(filePath(dirName,acceptAbsPath)), 0777 );
 #endif
+    return status == 0;
 }
 
 bool QDir::rmdir( const QString &dirName, bool acceptAbsPath ) const
 {
     return ::rmdir( QFile::encodeName(filePath(dirName,acceptAbsPath)) ) == 0;
 }
 
 bool QDir::isReadable() const
 {
     return ::access( QFile::encodeName(dPath), R_OK | X_OK ) == 0;
 }
 
 bool QDir::isRoot() const
 {
     return dPath == QString::fromLatin1("/");
 }
 
 bool QDir::rename( const QString &name, const QString &newName,
 		   bool acceptAbsPaths	)
 {
     if ( name.isEmpty() || newName.isEmpty() ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QDir::rename: Empty or null file name(s)" );
 #endif
 	return FALSE;
     }
     QString fn1 = filePath( name, acceptAbsPaths );
     QString fn2 = filePath( newName, acceptAbsPaths );
     return ::rename( QFile::encodeName(fn1),
 		     QFile::encodeName(fn2) ) == 0;
 }
 
 bool QDir::setCurrent( const QString &path )
 {
     int r;
     r = ::chdir( QFile::encodeName(path) );
     return r >= 0;
 }
 
 QString QDir::currentDirPath()
 {
     QString result;
 
     struct stat st;
     if ( ::stat( ".", &st ) == 0 ) {
 	char currentName[PATH_MAX+1];
 	if ( ::getcwd( currentName, PATH_MAX ) )
 	    result = QFile::decodeName(currentName);
 #if defined(QT_DEBUG)
 	if ( result.isNull() )
 	    qWarning( "QDir::currentDirPath: getcwd() failed" );
 #endif
     } else {
 #if defined(QT_DEBUG)
 	qWarning( "QDir::currentDirPath: stat(\".\") failed" );
 #endif
     }
     slashify( result );
     return result;
 }
 
 QString QDir::rootDirPath()
 {
     QString d = QString::fromLatin1( "/" );
     return d;
 }
 
 bool QDir::isRelativePath( const QString &path )
 {
     int len = path.length();
     if ( len == 0 )
 	return TRUE;
     return path[0] != '/';
 }
 
 bool QDir::readDirEntries( const QString &nameFilter,
 			   int filterSpec, int sortSpec )
 {
     int i;
     if ( !fList ) {
 	fList  = new QStringList;
 	Q_CHECK_PTR( fList );
 	fiList = new QFileInfoList;
 	Q_CHECK_PTR( fiList );
 	fiList->setAutoDelete( TRUE );
     } else {
 	fList->clear();
 	fiList->clear();
     }
 
-    QStringList filters = qt_makeFilterList( nameFilter );
+    QValueList<QRegExp> filters = qt_makeFilterList( nameFilter );
 
     bool doDirs	    = (filterSpec & Dirs)	!= 0;
     bool doFiles    = (filterSpec & Files)	!= 0;
     bool noSymLinks = (filterSpec & NoSymLinks) != 0;
     bool doReadable = (filterSpec & Readable)	!= 0;
     bool doWritable = (filterSpec & Writable)	!= 0;
     bool doExecable = (filterSpec & Executable) != 0;
     bool doHidden   = (filterSpec & Hidden)	!= 0;
     bool doSystem   = (filterSpec & System)     != 0;
 
-#if defined(Q_OS_OS2EMX)
-    //QRegExp   wc( nameFilter, FALSE, TRUE );	// wild card, case insensitive
-#else
-    //QRegExp   wc( nameFilter, TRUE, TRUE );	// wild card, case sensitive
-#endif
     QFileInfo fi;
     DIR	     *dir;
     dirent   *file;
 
     dir = opendir( QFile::encodeName(dPath) );
     if ( !dir )
 	return FALSE; // cannot read the directory
 
-    while ( (file = readdir(dir)) ) {
+#if defined(QT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_CYGWIN)
+    union {
+	struct dirent mt_file;
+	char b[sizeof(struct dirent) + MAXNAMLEN + 1];
+    } u;
+    while ( readdir_r(dir, &u.mt_file, &file ) == 0 && file )
+#else
+    while ( (file = readdir(dir)) )
+#endif // QT_THREAD_SUPPORT && _POSIX_THREAD_SAFE_FUNCTIONS
+    {
 	QString fn = QFile::decodeName(file->d_name);
 	fi.setFile( *this, fn );
-	if ( !match( filters, fn ) && !(allDirs && fi.isDir()) )
+	if ( !qt_matchFilterList(filters, fn) && !(allDirs && fi.isDir()) )
 	     continue;
 	if  ( (doDirs && fi.isDir()) || (doFiles && fi.isFile()) ||
 	      (doSystem && (!fi.isFile() && !fi.isDir())) ) {
 	    if ( noSymLinks && fi.isSymLink() )
 	        continue;
 	    if ( (filterSpec & RWEMask) != 0 )
 	        if ( (doReadable && !fi.isReadable()) ||
 	             (doWritable && !fi.isWritable()) ||
 	             (doExecable && !fi.isExecutable()) )
 	            continue;
 	    if ( !doHidden && fn[0] == '.' &&
 	         fn != QString::fromLatin1(".")
 	         && fn != QString::fromLatin1("..") )
 	        continue;
 	    fiList->append( new QFileInfo( fi ) );
 	}
     }
     if ( closedir(dir) != 0 ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QDir::readDirEntries: Cannot close the directory: %s",
 		  dPath.local8Bit().data() );
 #endif
     }
 
     // Sort...
     if(fiList->count()) {
 	QDirSortItem* si= new QDirSortItem[fiList->count()];
 	QFileInfo* itm;
 	i=0;
 	for (itm = fiList->first(); itm; itm = fiList->next())
 	    si[i++].item = itm;
 	qt_cmp_si_sortSpec = sortSpec;
 	qsort( si, i, sizeof(si[0]), qt_cmp_si );
 	// put them back in the list
 	fiList->setAutoDelete( FALSE );
 	fiList->clear();
 	int j;
 	for ( j=0; j<i; j++ ) {
 	    fiList->append( si[j].item );
 	    fList->append( si[j].item->fileName() );
 	}
 	delete [] si;
 	fiList->setAutoDelete( TRUE );
     }
 
     if ( filterSpec == (FilterSpec)filtS && sortSpec == (SortSpec)sortS &&
 	 nameFilter == nameFilt )
 	dirty = FALSE;
     else
 	dirty = TRUE;
     return TRUE;
 }
 
 const QFileInfoList * QDir::drives()
 {
     // at most one instance of QFileInfoList is leaked, and this variable
     // points to that list
     static QFileInfoList * knownMemoryLeak = 0;
 
     if ( !knownMemoryLeak ) {
 
 #ifdef QT_THREAD_SUPPORT
-	QMutexLocker locker( qt_global_mutexpool->get( &knownMemoryLeak ) );
+	QMutexLocker locker( qt_global_mutexpool ?
+			     qt_global_mutexpool->get( &knownMemoryLeak ) : 0 );
 #endif // QT_THREAD_SUPPORT
 
 	if ( !knownMemoryLeak ) {
 	    knownMemoryLeak = new QFileInfoList;
 	    // non-win32 versions both use just one root directory
 	    knownMemoryLeak->append( new QFileInfo( rootDirPath() ) );
 	}
     }
 
     return knownMemoryLeak;
 }
 #endif //QT_NO_DIR
diff --git a/qmake/tools/qfile.cpp b/qmake/tools/qfile.cpp
index a578b49..c088b55 100644
--- a/qmake/tools/qfile.cpp
+++ b/qmake/tools/qfile.cpp
@@ -1,614 +1,615 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QFile class
 **
 ** Created : 930812
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qplatformdefs.h"
 
 // POSIX Large File Support redefines open -> open64
 #if defined(open)
 # undef open
 #endif
 
 // POSIX Large File Support redefines truncate -> truncate64
 #if defined(truncate)
 # undef truncate
 #endif
 
 #include "qfile.h"
 
 
 extern bool qt_file_access( const QString& fn, int t );
 
 /*!
     \class QFile qfile.h
     \reentrant
     \brief The QFile class is an I/O device that operates on files.
 
     \ingroup io
     \mainclass
 
     QFile is an I/O device for reading and writing binary and text
     files. A QFile may be used by itself or more conveniently with a
     QDataStream or QTextStream.
 
     The file name is usually passed in the constructor but can be
     changed with setName(). You can check for a file's existence with
     exists() and remove a file with remove().
 
     The file is opened with open(), closed with close() and flushed
     with flush(). Data is usually read and written using QDataStream
     or QTextStream, but you can read with readBlock() and readLine()
     and write with writeBlock(). QFile also supports getch(),
     ungetch() and putch().
 
     The size of the file is returned by size(). You can get the
     current file position or move to a new file position using the
     at() functions. If you've reached the end of the file, atEnd()
     returns TRUE. The file handle is returned by handle().
 
     Here is a code fragment that uses QTextStream to read a text file
     line by line. It prints each line with a line number.
     \code
     QStringList lines;
     QFile file( "file.txt" );
     if ( file.open( IO_ReadOnly ) ) {
 	QTextStream stream( &file );
 	QString line;
 	int i = 1;
-	while ( !stream.eof() ) {
+	while ( !stream.atEnd() ) {
 	    line = stream.readLine(); // line of text excluding '\n'
 	    printf( "%3d: %s\n", i++, line.latin1() );
 	    lines += line;
 	}
 	file.close();
     }
     \endcode
 
     Writing text is just as easy. The following example shows how to
     write the data we read into the string list from the previous
     example:
     \code
     QFile file( "file.txt" );
     if ( file.open( IO_WriteOnly ) ) {
 	QTextStream stream( &file );
 	for ( QStringList::Iterator it = lines.begin(); it != lines.end(); ++it )
 	    stream << *it << "\n";
 	file.close();
     }
     \endcode
 
     The QFileInfo class holds detailed information about a file, such
     as access permissions, file dates and file types.
 
     The QDir class manages directories and lists of file names.
 
     Qt uses Unicode file names. If you want to do your own I/O on Unix
     systems you may want to use encodeName() (and decodeName()) to
     convert the file name into the local encoding.
 
     \important readAll()
 
     \sa QDataStream, QTextStream
 */
 
 /*!
     \fn Q_LONG QFile::writeBlock( const QByteArray& data )
 
     \overload
 */
 
 
 /*!
     Constructs a QFile with no name.
 */
 
 QFile::QFile()
 {
     init();
 }
 
 /*!
     Constructs a QFile with a file name \a name.
 
     \sa setName()
 */
 
 QFile::QFile( const QString &name )
     : fn(name)
 {
     init();
 }
 
 
 /*!
     Destroys a QFile. Calls close().
 */
 
 QFile::~QFile()
 {
     close();
 }
 
 
 /*!
   \internal
   Initialize internal data.
 */
 
 void QFile::init()
 {
     setFlags( IO_Direct );
     setStatus( IO_Ok );
     fh	   = 0;
     fd	   = 0;
     length = 0;
     ioIndex = 0;
     ext_f  = FALSE;				// not an external file handle
 }
 
 
 /*!
     \fn QString QFile::name() const
 
     Returns the name set by setName().
 
     \sa setName(), QFileInfo::fileName()
 */
 
 /*!
     Sets the name of the file to \a name. The name can have no path, a
     relative path or an absolute absolute path.
 
     Do not call this function if the file has already been opened.
 
     If the file name has no path or a relative path, the path used
     will be whatever the application's current directory path is
     \e{at the time of the open()} call.
 
     Example:
     \code
 	QFile file;
 	QDir::setCurrent( "/tmp" );
 	file.setName( "readme.txt" );
 	QDir::setCurrent( "/home" );
 	file.open( IO_ReadOnly );      // opens "/home/readme.txt" under Unix
     \endcode
 
     Note that the directory separator "/" works for all operating
     systems supported by Qt.
 
     \sa name(), QFileInfo, QDir
 */
 
 void QFile::setName( const QString &name )
 {
     if ( isOpen() ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QFile::setName: File is open" );
 #endif
 	close();
     }
     fn = name;
 }
 
 /*!
     \overload
 
     Returns TRUE if this file exists; otherwise returns FALSE.
 
     \sa name()
 */
 
 bool QFile::exists() const
 {
     return qt_file_access( fn, F_OK );
 }
 
 /*!
     Returns TRUE if the file given by \a fileName exists; otherwise
     returns FALSE.
 */
 
 bool QFile::exists( const QString &fileName )
 {
     return qt_file_access( fileName, F_OK );
 }
 
 
 /*!
     Removes the file specified by the file name currently set. Returns
     TRUE if successful; otherwise returns FALSE.
 
     The file is closed before it is removed.
 */
 
 bool QFile::remove()
 {
     close();
     return remove( fn );
 }
 
 #if defined(Q_OS_MAC) || defined(Q_OS_MSDOS) || defined(Q_OS_WIN32) || defined(Q_OS_OS2)
 # define HAS_TEXT_FILEMODE			// has translate/text filemode
 #endif
 #if defined(O_NONBLOCK)
 # define HAS_ASYNC_FILEMODE
 # define OPEN_ASYNC O_NONBLOCK
 #elif defined(O_NDELAY)
 # define HAS_ASYNC_FILEMODE
 # define OPEN_ASYNC O_NDELAY
 #endif
 
 /*!
     Flushes the file buffer to the disk.
 
     close() also flushes the file buffer.
 */
 
 void QFile::flush()
 {
     if ( isOpen() && fh )			// can only flush open/buffered
 	fflush( fh );				//   file
 }
 
 /*! \reimp
     \fn QIODevice::Offset QFile::at() const
 */
 
 /*!
     Returns TRUE if the end of file has been reached; otherwise returns FALSE.
+    If QFile has not been open()'d, then the behavior is undefined.
 
     \sa size()
 */
 
 bool QFile::atEnd() const
 {
     if ( !isOpen() ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QFile::atEnd: File is not open" );
 #endif
 	return FALSE;
     }
     if ( isDirectAccess() && !isTranslated() ) {
 	if ( at() < length )
 	    return FALSE;
     }
     return QIODevice::atEnd();
 }
 
 /*!
     Reads a line of text.
 
     Reads bytes from the file into the char* \a p, until end-of-line
     or \a maxlen bytes have been read, whichever occurs first. Returns
     the number of bytes read, or -1 if there was an error. Any
     terminating newline is not stripped.
 
     This function is only efficient for buffered files. Avoid
     readLine() for files that have been opened with the \c IO_Raw
     flag.
 
     \sa readBlock(), QTextStream::readLine()
 */
 
 Q_LONG QFile::readLine( char *p, Q_ULONG maxlen )
 {
     if ( maxlen == 0 )				// application bug?
 	return 0;
 #if defined(QT_CHECK_STATE)
     Q_CHECK_PTR( p );
     if ( !isOpen() ) {				// file not open
 	qWarning( "QFile::readLine: File not open" );
 	return -1;
     }
     if ( !isReadable() ) {			// reading not permitted
 	qWarning( "QFile::readLine: Read operation not permitted" );
 	return -1;
     }
 #endif
     Q_LONG nread;				// number of bytes read
     if ( isRaw() ) {				// raw file
 	nread = QIODevice::readLine( p, maxlen );
     } else {					// buffered file
 	p = fgets( p, maxlen, fh );
 	if ( p ) {
 	    nread = qstrlen( p );
 	    if ( !isSequentialAccess() )
 		ioIndex += nread;
 	} else {
 	    nread = -1;
 	    setStatus(IO_ReadError);
 	}
     }
     return nread;
 }
 
 
 /*!
     \overload
 
     Reads a line of text.
 
     Reads bytes from the file into string \a s, until end-of-line or
     \a maxlen bytes have been read, whichever occurs first. Returns
     the number of bytes read, or -1 if there was an error, e.g. end of
     file. Any terminating newline is not stripped.
 
     This function is only efficient for buffered files. Avoid using
     readLine() for files that have been opened with the \c IO_Raw
     flag.
 
     Note that the string is read as plain Latin1 bytes, not Unicode.
 
     \sa readBlock(), QTextStream::readLine()
 */
 
 Q_LONG QFile::readLine( QString& s, Q_ULONG maxlen )
 {
     QByteArray ba(maxlen);
     Q_LONG l = readLine(ba.data(),maxlen);
     if ( l >= 0 ) {
 	ba.truncate(l);
 	s = QString(ba);
     }
     return l;
 }
 
 
 /*!
     Reads a single byte/character from the file.
 
     Returns the byte/character read, or -1 if the end of the file has
     been reached.
 
     \sa putch(), ungetch()
 */
 
 int QFile::getch()
 {
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {				// file not open
 	qWarning( "QFile::getch: File not open" );
 	return EOF;
     }
     if ( !isReadable() ) {			// reading not permitted
 	qWarning( "QFile::getch: Read operation not permitted" );
 	return EOF;
     }
 #endif
 
     int ch;
 
     if ( !ungetchBuffer.isEmpty() ) {
 	int len = ungetchBuffer.length();
 	ch = ungetchBuffer[ len-1 ];
 	ungetchBuffer.truncate( len - 1 );
 	return ch;
     }
 
     if ( isRaw() ) {				// raw file (inefficient)
 	char buf[1];
 	ch = readBlock( buf, 1 ) == 1 ? buf[0] : EOF;
     } else {					// buffered file
 	if ( (ch = getc( fh )) != EOF )
 	    if ( !isSequentialAccess() )
 		ioIndex++;
 	else
 	    setStatus(IO_ReadError);
     }
     return ch;
 }
 
 /*!
     Writes the character \a ch to the file.
 
     Returns \a ch, or -1 if some error occurred.
 
     \sa getch(), ungetch()
 */
 
 int QFile::putch( int ch )
 {
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {				// file not open
 	qWarning( "QFile::putch: File not open" );
 	return EOF;
     }
     if ( !isWritable() ) {			// writing not permitted
 	qWarning( "QFile::putch: Write operation not permitted" );
 	return EOF;
     }
 #endif
     if ( isRaw() ) {				// raw file (inefficient)
 	char buf[1];
 	buf[0] = ch;
 	ch = writeBlock( buf, 1 ) == 1 ? ch : EOF;
     } else {					// buffered file
 	if ( (ch = putc( ch, fh )) != EOF ) {
 	    if ( !isSequentialAccess() )
 		ioIndex++;
 	    if ( ioIndex > length )		// update file length
 		length = ioIndex;
 	} else {
 	    setStatus(IO_WriteError);
 	}
     }
     return ch;
 }
 
 /*!
     Puts the character \a ch back into the file and decrements the
     index if it is not zero.
 
     This function is normally called to "undo" a getch() operation.
 
     Returns \a ch, or -1 if an error occurred.
 
     \sa getch(), putch()
 */
 
 int QFile::ungetch( int ch )
 {
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {				// file not open
 	qWarning( "QFile::ungetch: File not open" );
 	return EOF;
     }
     if ( !isReadable() ) {			// reading not permitted
 	qWarning( "QFile::ungetch: Read operation not permitted" );
 	return EOF;
     }
 #endif
     if ( ch == EOF )				// cannot unget EOF
 	return ch;
 
     if ( isSequentialAccess() && !fh) {
 	// pipe or similar => we cannot ungetch, so do it manually
 	ungetchBuffer +=ch;
 	return ch;
     }
 
     if ( isRaw() ) {				// raw file (very inefficient)
 	char buf[1];
 	at( ioIndex-1 );
 	buf[0] = ch;
 	if ( writeBlock(buf, 1) == 1 )
 	    at ( ioIndex-1 );
 	else
 	    ch = EOF;
     } else {					// buffered file
 	if ( (ch = ungetc(ch, fh)) != EOF )
 	    if ( !isSequentialAccess() )
 		ioIndex--;
 	else
 	    setStatus( IO_ReadError );
     }
     return ch;
 }
 
 
 static QCString locale_encoder( const QString &fileName )
 {
     return fileName.local8Bit();
 }
 
 
 static QFile::EncoderFn encoder = locale_encoder;
 
 /*!
     When you use QFile, QFileInfo, and QDir to access the file system
     with Qt, you can use Unicode file names. On Unix, these file names
     are converted to an 8-bit encoding. If you want to do your own
     file I/O on Unix, you should convert the file name using this
     function. On Windows NT/2000, Unicode file names are supported
     directly in the file system and this function should be avoided.
     On Windows 95, non-Latin1 locales are not supported.
 
     By default, this function converts \a fileName to the local 8-bit
     encoding determined by the user's locale. This is sufficient for
     file names that the user chooses. File names hard-coded into the
     application should only use 7-bit ASCII filename characters.
 
     The conversion scheme can be changed using setEncodingFunction().
     This might be useful if you wish to give the user an option to
     store file names in UTF-8, etc., but be aware that such file names
     would probably then be unrecognizable when seen by other programs.
 
     \sa decodeName()
 */
 
 QCString QFile::encodeName( const QString &fileName )
 {
     return (*encoder)(fileName);
 }
 
 /*!
     \enum QFile::EncoderFn
 
     This is used by QFile::setEncodingFunction().
 */
 
 /*!
     \nonreentrant
 
     Sets the function for encoding Unicode file names to \a f. The
     default encodes in the locale-specific 8-bit encoding.
 
     \sa encodeName()
 */
 void QFile::setEncodingFunction( EncoderFn f )
 {
     encoder = f;
 }
 
 static
 QString locale_decoder( const QCString &localFileName )
 {
     return QString::fromLocal8Bit(localFileName);
 }
 
 static QFile::DecoderFn decoder = locale_decoder;
 
 /*!
     This does the reverse of QFile::encodeName() using \a localFileName.
 
     \sa setDecodingFunction()
 */
 QString QFile::decodeName( const QCString &localFileName )
 {
     return (*decoder)(localFileName);
 }
 
 /*!
     \enum QFile::DecoderFn
 
     This is used by QFile::setDecodingFunction().
 */
 
 /*!
     \nonreentrant
 
     Sets the function for decoding 8-bit file names to \a f. The
     default uses the locale-specific 8-bit encoding.
 
     \sa encodeName(), decodeName()
 */
 
 void QFile::setDecodingFunction( DecoderFn f )
 {
     decoder = f;
 }
 
diff --git a/qmake/tools/qfile_unix.cpp b/qmake/tools/qfile_unix.cpp
index 2d5a856..460bf06 100644
--- a/qmake/tools/qfile_unix.cpp
+++ b/qmake/tools/qfile_unix.cpp
@@ -1,687 +1,692 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QFile class
 **
 ** Created : 950628
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses for Unix/X11 or for Qt/Embedded may use this file in accordance
 ** with the Qt Commercial License Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qplatformdefs.h"
 
 // POSIX Large File Support redefines open -> open64
 static inline int qt_open(const char *pathname, int flags, mode_t mode)
 { return ::open(pathname, flags, mode); }
 #if defined(open)
 # undef open
 #endif
 
 // POSIX Large File Support redefines truncate -> truncate64
 #if defined(truncate)
 # undef truncate
 #endif
 
 #include "qfile.h"
 #include <errno.h>
 #include <limits.h>
 
 
 bool qt_file_access( const QString& fn, int t )
 {
     if ( fn.isEmpty() )
 	return FALSE;
     return ::access( QFile::encodeName(fn), t ) == 0;
 }
 
 /*!
     \overload
     Removes the file \a fileName.
   Returns TRUE if successful, otherwise FALSE.
 */
 
 bool QFile::remove( const QString &fileName )
 {
     if ( fileName.isEmpty() ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QFile::remove: Empty or null file name" );
 #endif
 	return FALSE;
     }
     return unlink( QFile::encodeName(fileName) ) == 0;
 }
 
 #if defined(O_NONBLOCK)
 # define HAS_ASYNC_FILEMODE
 # define OPEN_ASYNC O_NONBLOCK
 #elif defined(O_NDELAY)
 # define HAS_ASYNC_FILEMODE
 # define OPEN_ASYNC O_NDELAY
 #endif
 
 /*!
     Opens the file specified by the file name currently set, using the
     mode \a m. Returns TRUE if successful, otherwise FALSE.
 
     \keyword IO_Raw
     \keyword IO_ReadOnly
     \keyword IO_WriteOnly
     \keyword IO_ReadWrite
     \keyword IO_Append
     \keyword IO_Truncate
     \keyword IO_Translate
 
     The mode parameter \a m must be a combination of the following flags:
     \table
     \header \i Flag \i Meaning
     \row \i IO_Raw
 	 \i Raw (non-buffered) file access.
     \row \i IO_ReadOnly
 	 \i Opens the file in read-only mode.
     \row \i IO_WriteOnly
 	 \i Opens the file in write-only mode. If this flag is used
 	    with another flag, e.g. \c IO_ReadOnly or \c IO_Raw or \c
 	    IO_Append, the file is \e not truncated; but if used on
 	    its own (or with \c IO_Truncate), the file is truncated.
     \row \i IO_ReadWrite
 	 \i Opens the file in read/write mode, equivalent to \c
 	    (IO_ReadOnly | IO_WriteOnly).
     \row \i IO_Append
 	 \i Opens the file in append mode. (You must actually use \c
 	    (IO_WriteOnly | IO_Append) to make the file writable and
 	    to go into append mode.) This mode is very useful when you
 	    want to write something to a log file. The file index is
 	    set to the end of the file. Note that the result is
 	    undefined if you position the file index manually using
 	    at() in append mode.
     \row \i IO_Truncate
 	 \i Truncates the file.
     \row \i IO_Translate
 	 \i Enables carriage returns and linefeed translation for text
 	    files under Windows.
     \endtable
 
     The raw access mode is best when I/O is block-operated using a 4KB
     block size or greater. Buffered access works better when reading
     small portions of data at a time.
 
     \warning When working with buffered files, data may not be written
     to the file at once. Call flush() to make sure that the data is
     really written.
 
     \warning If you have a buffered file opened for both reading and
     writing you must not perform an input operation immediately after
     an output operation or vice versa. You should always call flush()
     or a file positioning operation, e.g. at(), between input and
     output operations, otherwise the buffer may contain garbage.
 
     If the file does not exist and \c IO_WriteOnly or \c IO_ReadWrite
     is specified, it is created.
 
     Example:
     \code
 	QFile f1( "/tmp/data.bin" );
 	f1.open( IO_Raw | IO_ReadWrite );
 
 	QFile f2( "readme.txt" );
 	f2.open( IO_ReadOnly | IO_Translate );
 
 	QFile f3( "audit.log" );
 	f3.open( IO_WriteOnly | IO_Append );
     \endcode
 
     \sa name(), close(), isOpen(), flush()
 */
 
 bool QFile::open( int m )
 {
     if ( isOpen() ) {				// file already open
 #if defined(QT_CHECK_STATE)
 	qWarning( "QFile::open: File already open" );
 #endif
 	return FALSE;
     }
     if ( fn.isNull() ) {			// no file name defined
 #if defined(QT_CHECK_NULL)
 	qWarning( "QFile::open: No file name specified" );
 #endif
 	return FALSE;
     }
     init();					// reset params
     setMode( m );
     if ( !(isReadable() || isWritable()) ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "QFile::open: File access not specified" );
 #endif
 	return FALSE;
     }
     bool ok = TRUE;
     struct stat st;
     if ( isRaw() ) {
 	int oflags = O_RDONLY;
 	if ( isReadable() && isWritable() )
 	    oflags = O_RDWR;
 	else if ( isWritable() )
 	    oflags = O_WRONLY;
 	if ( flags() & IO_Append ) {		// append to end of file?
 	    if ( flags() & IO_Truncate )
 		oflags |= (O_CREAT | O_TRUNC);
 	    else
 		oflags |= (O_APPEND | O_CREAT);
 	    setFlags( flags() | IO_WriteOnly ); // append implies write
 	} else if ( isWritable() ) {		// create/trunc if writable
 	    if ( flags() & IO_Truncate )
 		oflags |= (O_CREAT | O_TRUNC);
 	    else
 		oflags |= O_CREAT;
 	}
 #if defined(HAS_TEXT_FILEMODE)
 	if ( isTranslated() )
 	    oflags |= OPEN_TEXT;
 	else
 	    oflags |= OPEN_BINARY;
 #endif
 #if defined(HAS_ASYNC_FILEMODE)
 	if ( isAsynchronous() )
 	    oflags |= OPEN_ASYNC;
 #endif
 	fd = qt_open( QFile::encodeName(fn), oflags, 0666 );
 
 	if ( fd != -1 ) {			// open successful
 	    ::fstat( fd, &st );			// get the stat for later usage
 	} else {
 	    ok = FALSE;
 	}
     } else {					// buffered file I/O
 	QCString perm;
 	char perm2[4];
 	bool try_create = FALSE;
 	if ( flags() & IO_Append ) {		// append to end of file?
 	    setFlags( flags() | IO_WriteOnly ); // append implies write
 	    perm = isReadable() ? "a+" : "a";
 	} else {
 	    if ( isReadWrite() ) {
 		if ( flags() & IO_Truncate ) {
 		    perm = "w+";
 		} else {
 		    perm = "r+";
 		    try_create = TRUE;		// try to create if not exists
 		}
 	    } else if ( isReadable() ) {
 		perm = "r";
 	    } else if ( isWritable() ) {
 		perm = "w";
 	    }
 	}
 	qstrcpy( perm2, perm );
 #if defined(HAS_TEXT_FILEMODE)
 	if ( isTranslated() )
 	    strcat( perm2, "t" );
 	else
 	    strcat( perm2, "b" );
 #endif
 	for (;;) { // At most twice
 
 	    fh = fopen( QFile::encodeName(fn), perm2 );
 
 	    if ( !fh && try_create ) {
 		perm2[0] = 'w';			// try "w+" instead of "r+"
 		try_create = FALSE;
 	    } else {
 		break;
 	    }
 	}
 	if ( fh ) {
 	    ::fstat( fileno(fh), &st ); 	// get the stat for later usage
 	} else {
 	    ok = FALSE;
 	}
     }
     if ( ok ) {
 	setState( IO_Open );
 	// on successful open the file stat was got; now test what type
 	// of file we have
 	if ( (st.st_mode & S_IFMT) != S_IFREG ) {
 	    // non-seekable
 	    setType( IO_Sequential );
 	    length = INT_MAX;
 	    ioIndex = 0;
 	} else {
 	    length = (Offset)st.st_size;
 	    ioIndex = (flags() & IO_Append) == 0 ? 0 : length;
 	    if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
 		// try if you can read from it (if you can, it's a sequential
 		// device; e.g. a file in the /proc filesystem)
 		int c = getch();
 		if ( c != -1 ) {
 		    ungetch(c);
 		    setType( IO_Sequential );
 		    length = INT_MAX;
 		    ioIndex = 0;
 		}
 	    }
 	}
     } else {
 	init();
 	if ( errno == EMFILE )			// no more file handles/descrs
 	    setStatus( IO_ResourceError );
 	else
 	    setStatus( IO_OpenError );
     }
     return ok;
 }
 
 /*!
     \overload
   Opens a file in the mode \a m using an existing file handle \a f.
   Returns TRUE if successful, otherwise FALSE.
 
   Example:
   \code
     #include <stdio.h>
 
     void printError( const char* msg )
     {
 	QFile f;
 	f.open( IO_WriteOnly, stderr );
 	f.writeBlock( msg, qstrlen(msg) );	// write to stderr
 	f.close();
     }
   \endcode
 
   When a QFile is opened using this function, close() does not actually
   close the file, only flushes it.
 
   \warning If \a f is \c stdin, \c stdout, \c stderr, you may not
   be able to seek.  See QIODevice::isSequentialAccess() for more
   information.
 
   \sa close()
 */
 
 bool QFile::open( int m, FILE *f )
 {
     if ( isOpen() ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "QFile::open: File already open" );
 #endif
 	return FALSE;
     }
     init();
     setMode( m &~IO_Raw );
     setState( IO_Open );
     fh = f;
     ext_f = TRUE;
     struct stat st;
     ::fstat( fileno(fh), &st );
 #if defined(QT_LARGEFILE_SUPPORT)
     ioIndex = (Offset)ftello( fh );
 #else
     ioIndex = (Offset)ftell( fh );
 #endif
     if ( (st.st_mode & S_IFMT) != S_IFREG || f == stdin ) { //stdin is non seekable
 	// non-seekable
 	setType( IO_Sequential );
 	length = INT_MAX;
 	ioIndex = 0;
     } else {
 	length = (Offset)st.st_size;
 	if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
 	    // try if you can read from it (if you can, it's a sequential
 	    // device; e.g. a file in the /proc filesystem)
 	    int c = getch();
 	    if ( c != -1 ) {
 		ungetch(c);
 		setType( IO_Sequential );
 		length = INT_MAX;
 		ioIndex = 0;
 	    }
 	}
     }
     return TRUE;
 }
 
 /*!
     \overload
   Opens a file in the mode \a m using an existing file descriptor \a f.
   Returns TRUE if successful, otherwise FALSE.
 
   When a QFile is opened using this function, close() does not actually
   close the file.
 
   The QFile that is opened using this function, is automatically set to be in
   raw mode; this means that the file input/output functions are slow. If you
   run into performance issues, you should try to use one of the other open
   functions.
 
   \warning If \a f is one of 0 (stdin), 1 (stdout) or 2 (stderr), you may not
   be able to seek. size() is set to \c INT_MAX (in limits.h).
 
   \sa close()
 */
 
 
 bool QFile::open( int m, int f )
 {
     if ( isOpen() ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "QFile::open: File already open" );
 #endif
 	return FALSE;
     }
     init();
     setMode( m |IO_Raw );
     setState( IO_Open );
     fd = f;
     ext_f = TRUE;
     struct stat st;
     ::fstat( fd, &st );
     ioIndex = (Offset)::lseek(fd, 0, SEEK_CUR);
     if ( (st.st_mode & S_IFMT) != S_IFREG || f == 0 ) { // stdin is not seekable...
 	// non-seekable
 	setType( IO_Sequential );
 	length = INT_MAX;
 	ioIndex = 0;
     } else {
 	length = (Offset)st.st_size;
 	if ( length == 0 && isReadable() ) {
 	    // try if you can read from it (if you can, it's a sequential
 	    // device; e.g. a file in the /proc filesystem)
 	    int c = getch();
 	    if ( c != -1 ) {
 		ungetch(c);
 		setType( IO_Sequential );
 		length = INT_MAX;
 		ioIndex = 0;
 	    }
 	    resetStatus();
 	}
     }
     return TRUE;
 }
 
 /*!
   Returns the file size.
   \sa at()
 */
 
 QIODevice::Offset QFile::size() const
 {
     struct stat st;
+    int ret = 0;
     if ( isOpen() ) {
-	::fstat( fh ? fileno(fh) : fd, &st );
+	ret = ::fstat( fh ? fileno(fh) : fd, &st );
     } else {
-	::stat( QFile::encodeName(fn), &st );
+	ret = ::stat( QFile::encodeName(fn), &st );
     }
+    if ( ret == -1 )
+	return 0;
 #if defined(QT_LARGEFILE_SUPPORT) && !defined(QT_ABI_64BITOFFSET)
     return (uint)st.st_size > UINT_MAX ? UINT_MAX : (QIODevice::Offset)st.st_size;
 #else
     return st.st_size;
 #endif
 }
 
 
 /*!
     \overload
 
     Sets the file index to \a pos. Returns TRUE if successful;
     otherwise returns FALSE.
 
     Example:
     \code
     QFile f( "data.bin" );
     f.open( IO_ReadOnly );  // index set to 0
     f.at( 100 );	    // set index to 100
     f.at( f.at()+50 );	    // set index to 150
     f.at( f.size()-80 );    // set index to 80 before EOF
     f.close();
     \endcode
 
     Use \c at() without arguments to retrieve the file offset.
 
     \warning The result is undefined if the file was open()'ed using
     the \c IO_Append specifier.
 
     \sa size(), open()
 */
 
 bool QFile::at( Offset pos )
 {
     if ( !isOpen() ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QFile::at: File is not open" );
 #endif
 	return FALSE;
     }
     if ( isSequentialAccess() )
 	return FALSE;
     bool ok;
     if ( isRaw() ) {
 	off_t l = ::lseek( fd, pos, SEEK_SET );
 	ok = ( l != -1 );
 	pos = (Offset)l;
     } else {					// buffered file
 #if defined(QT_LARGEFILE_SUPPORT)
 	ok = ( ::fseeko(fh, pos, SEEK_SET) == 0 );
 #else
 	ok = ( ::fseek(fh, pos, SEEK_SET) == 0 );
 #endif
     }
     if ( ok )
 	ioIndex = pos;
 #if defined(QT_CHECK_RANGE)
     else
 #if defined(QT_LARGEFILE_SUPPORT) && defined(QT_ABI_64BITOFFSET)
 	qWarning( "QFile::at: Cannot set file position %llu", pos );
 #else
 	qWarning( "QFile::at: Cannot set file position %lu", pos );
 #endif
 #endif
     return ok;
 }
 
 /*!
   \reimp
 
   \warning We have experienced problems with some C libraries when a buffered
   file is opened for both reading and writing. If a read operation takes place
   immediately after a write operation, the read buffer contains garbage data.
   Worse, the same garbage is written to the file. Calling flush() before
   readBlock() solved this problem.
 */
 
 Q_LONG QFile::readBlock( char *p, Q_ULONG len )
 {
 #if defined(QT_CHECK_NULL)
     if ( !p )
 	qWarning( "QFile::readBlock: Null pointer error" );
 #endif
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {
 	qWarning( "QFile::readBlock: File not open" );
 	return -1;
     }
     if ( !isReadable() ) {
 	qWarning( "QFile::readBlock: Read operation not permitted" );
 	return -1;
     }
 #endif
     Q_ULONG nread = 0;					// number of bytes read
     if ( !ungetchBuffer.isEmpty() ) {
 	// need to add these to the returned string.
 	uint l = ungetchBuffer.length();
 	while( nread < l ) {
-	    *p = ungetchBuffer[ l - nread - 1 ];
+	    *p = ungetchBuffer.at( l - nread - 1 );
 	    p++;
 	    nread++;
 	}
 	ungetchBuffer.truncate( l - nread );
     }
 
     if ( nread < len ) {
 	if ( isRaw() ) {				// raw file
 	    nread += ::read( fd, p, len-nread );
 	    if ( len && nread <= 0 ) {
 		nread = 0;
 		setStatus(IO_ReadError);
 	    }
 	} else {					// buffered file
 	    nread += fread( p, 1, len-nread, fh );
 	    if ( (uint)nread != len ) {
 		if ( ferror( fh ) || nread==0 )
 		    setStatus(IO_ReadError);
 	    }
 	}
     }
     if ( !isSequentialAccess() )
 	ioIndex += nread;
     return nread;
 }
 
 
 /*! \reimp
 
   Writes \a len bytes from \a p to the file and returns the number of
   bytes actually written.
 
   Returns -1 if a serious error occurred.
 
   \warning When working with buffered files, data may not be written
   to the file at once. Call flush() to make sure the data is really
   written.
 
   \sa readBlock()
 */
 
 Q_LONG QFile::writeBlock( const char *p, Q_ULONG len )
 {
 #if defined(QT_CHECK_NULL)
     if ( p == 0 && len != 0 )
 	qWarning( "QFile::writeBlock: Null pointer error" );
 #endif
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {				// file not open
 	qWarning( "QFile::writeBlock: File not open" );
 	return -1;
     }
     if ( !isWritable() ) {			// writing not permitted
 	qWarning( "QFile::writeBlock: Write operation not permitted" );
 	return -1;
     }
 #endif
     Q_ULONG nwritten;				// number of bytes written
     if ( isRaw() )				// raw file
 	nwritten = ::write( fd, (void *)p, len );
     else					// buffered file
 	nwritten = fwrite( p, 1, len, fh );
     if ( nwritten != len ) {		// write error
 	if ( errno == ENOSPC )			// disk is full
 	    setStatus( IO_ResourceError );
 	else
 	    setStatus( IO_WriteError );
 	if ( !isSequentialAccess() ) {
 	    if ( isRaw() )			// recalc file position
 		ioIndex = (Offset)::lseek( fd, 0, SEEK_CUR );
 	    else
 #if defined(QT_LARGEFILE_SUPPORT)
 		ioIndex = (Offset)::fseeko( fh, 0, SEEK_CUR );
 #else
 		ioIndex = (Offset)::fseek( fh, 0, SEEK_CUR );
 #endif
 	}
     } else {
 	if ( !isSequentialAccess() )
 	    ioIndex += nwritten;
     }
     if ( ioIndex > length )			// update file length
 	length = ioIndex;
     return nwritten;
 }
 
 /*!
   Returns the file handle of the file.
 
   This is a small positive integer, suitable for use with C library
-  functions such as fdopen() and fcntl(), as well as with QSocketNotifier.
+  functions such as fdopen() and fcntl(). On systems that use file 
+  descriptors for sockets (ie. Unix systems, but not Windows) the handle
+  can be used with QSocketNotifier as well.
 
   If the file is not open or there is an error, handle() returns -1.
 
   \sa QSocketNotifier
 */
 
 int QFile::handle() const
 {
     if ( !isOpen() )
 	return -1;
     else if ( fh )
 	return fileno( fh );
     else
 	return fd;
 }
 
 /*!
   Closes an open file.
 
   The file is not closed if it was opened with an existing file handle.
   If the existing file handle is a \c FILE*, the file is flushed.
   If the existing file handle is an \c int file descriptor, nothing
   is done to the file.
 
   Some "write-behind" filesystems may report an unspecified error on
   closing the file. These errors only indicate that something may
   have gone wrong since the previous open(). In such a case status()
   reports IO_UnspecifiedError after close(), otherwise IO_Ok.
 
   \sa open(), flush()
 */
 
 
 void QFile::close()
 {
     bool ok = FALSE;
     if ( isOpen() ) {				// file is not open
 	if ( fh ) {				// buffered file
 	    if ( ext_f )
 		ok = fflush( fh ) != -1;	// flush instead of closing
 	    else
 		ok = fclose( fh ) != -1;
 	} else {				// raw file
 	    if ( ext_f )
 		ok = TRUE;			// cannot close
 	    else
 		ok = ::close( fd ) != -1;
 	}
 	init();					// restore internal state
     }
     if (!ok)
 	setStatus( IO_UnspecifiedError );
 
     return;
 }
diff --git a/qmake/tools/qfileinfo.cpp b/qmake/tools/qfileinfo.cpp
index 3af7932..a78f4fa 100644
--- a/qmake/tools/qfileinfo.cpp
+++ b/qmake/tools/qfileinfo.cpp
@@ -1,659 +1,661 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QFileInfo class
 **
 ** Created : 950628
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qplatformdefs.h"
 
 #include "qfileinfo.h"
 #include "qdatetime.h"
 #include "qdir.h"
 #include "qfiledefs_p.h"
 #if defined(QT_LARGEFILE_SUPPORT) && !defined(QT_ABI_QT4)
 #include <limits.h>
 #endif
 
 
 extern bool qt_file_access( const QString& fn, int t );
 
 /*!
     \class QFileInfo
     \reentrant
     \brief The QFileInfo class provides system-independent file information.
 
     \ingroup io
 
     QFileInfo provides information about a file's name and position
     (path) in the file system, its access rights and whether it is a
     directory or symbolic link, etc. The file's size and last
     modified/read times are also available.
 
     A QFileInfo can point to a file with either a relative or an
     absolute file path. Absolute file paths begin with the directory
     separator "/" (or with a drive specification on Windows). Relative
     file names begin with a directory name or a file name and specify
     a path relative to the current working directory. An example of an
     absolute path is the string "/tmp/quartz". A relative path might
     look like "src/fatlib". You can use the function isRelative() to
     check whether a QFileInfo is using a relative or an absolute file
     path. You can call the function convertToAbs() to convert a
     relative QFileInfo's path to an absolute path.
 
     The file that the QFileInfo works on is set in the constructor or
     later with setFile(). Use exists() to see if the file exists and
     size() to get its size.
 
     To speed up performance, QFileInfo caches information about the
     file. Because files can be changed by other users or programs, or
     even by other parts of the same program, there is a function that
     refreshes the file information: refresh(). If you want to switch
     off a QFileInfo's caching and force it to access the file system
     every time you request information from it call setCaching(FALSE).
 
     The file's type is obtained with isFile(), isDir() and
     isSymLink(). The readLink() function provides the name of the file
     the symlink points to.
 
     Elements of the file's name can be extracted with dirPath() and
     fileName(). The fileName()'s parts can be extracted with
     baseName() and extension().
 
     The file's dates are returned by created(), lastModified() and
     lastRead(). Information about the file's access permissions is
     obtained with isReadable(), isWritable() and isExecutable(). The
     file's ownership is available from owner(), ownerId(), group() and
     groupId(). You can examine a file's permissions and ownership in a
     single statement using the permission() function.
 
     If you need to read and traverse directories, see the QDir class.
 */
 
 /*!
     \enum QFileInfo::PermissionSpec
 
     This enum is used by the permission() function to report the
     permissions and ownership of a file. The values may be OR-ed
     together to test multiple permissions and ownership values.
 
     \value ReadUser The file is readable by the user.
     \value WriteUser The file is writable by the user.
     \value ExeUser The file is executable by the user.
     \value ReadGroup The file is readable by the group.
     \value WriteGroup The file is writable by the group.
     \value ExeGroup The file is executable by the group.
     \value ReadOther The file is readable by anyone.
     \value WriteOther The file is writable by anyone.
     \value ExeOther The file is executable by anyone.
 */
 
 
 /*!
     Constructs a new empty QFileInfo.
 */
 
 QFileInfo::QFileInfo()
 {
     fic	  = 0;
     cache = TRUE;
 #if defined(Q_OS_UNIX)
     symLink = FALSE;
 #endif
 }
 
 /*!
     Constructs a new QFileInfo that gives information about the given
     file. The \a file can also include an absolute or relative path.
 
     \sa setFile(), isRelative(), QDir::setCurrent(), QDir::isRelativePath()
 */
 
 QFileInfo::QFileInfo( const QString &file )
 {
     fn	  = file;
     slashify( fn );
     fic	  = 0;
     cache = TRUE;
 #if defined(Q_OS_UNIX)
     symLink = FALSE;
 #endif
 }
 
 /*!
     Constructs a new QFileInfo that gives information about file \a
     file.
 
     If the \a file has a relative path, the QFileInfo will also have a
     relative path.
 
     \sa isRelative()
 */
 
 QFileInfo::QFileInfo( const QFile &file )
 {
     fn	  = file.name();
     slashify( fn );
     fic	  = 0;
     cache = TRUE;
 #if defined(Q_OS_UNIX)
     symLink = FALSE;
 #endif
 }
 
 /*!
     Constructs a new QFileInfo that gives information about the file
     called \a fileName in the directory \a d.
 
     If \a d has a relative path, the QFileInfo will also have a
     relative path.
 
     \sa isRelative()
 */
 #ifndef QT_NO_DIR
 QFileInfo::QFileInfo( const QDir &d, const QString &fileName )
 {
     fn	  = d.filePath( fileName );
     slashify( fn );
     fic	  = 0;
     cache = TRUE;
 #if defined(Q_OS_UNIX)
     symLink = FALSE;
 #endif
 }
 #endif
 /*!
     Constructs a new QFileInfo that is a copy of \a fi.
 */
 
 QFileInfo::QFileInfo( const QFileInfo &fi )
 {
     fn = fi.fn;
     if ( fi.fic ) {
 	fic = new QFileInfoCache;
 	*fic = *fi.fic;
     } else {
 	fic = 0;
     }
     cache = fi.cache;
 #if defined(Q_OS_UNIX)
     symLink = fi.symLink;
 #endif
 }
 
 /*!
     Destroys the QFileInfo and frees its resources.
 */
 
 QFileInfo::~QFileInfo()
 {
     delete fic;
 }
 
 
 /*!
     Makes a copy of \a fi and assigns it to this QFileInfo.
 */
 
 QFileInfo &QFileInfo::operator=( const QFileInfo &fi )
 {
     fn = fi.fn;
     if ( !fi.fic ) {
 	delete fic;
 	fic = 0;
     } else {
 	if ( !fic ) {
 	    fic = new QFileInfoCache;
 	    Q_CHECK_PTR( fic );
 	}
 	*fic = *fi.fic;
     }
     cache = fi.cache;
 #if defined(Q_OS_UNIX)
     symLink = fi.symLink;
 #endif
     return *this;
 }
 
 
 /*!
     Sets the file that the QFileInfo provides information about to \a
     file.
 
     The \a file can also include an absolute or relative file path.
     Absolute paths begin with the directory separator (e.g. "/" under
     Unix) or a drive specification (under Windows). Relative file
     names begin with a directory name or a file name and specify a
     path relative to the current directory.
 
     Example:
     \code
     QString absolute = "/local/bin";
     QString relative = "local/bin";
     QFileInfo absFile( absolute );
     QFileInfo relFile( relative );
 
     QDir::setCurrent( QDir::rootDirPath() );
     // absFile and relFile now point to the same file
 
     QDir::setCurrent( "/tmp" );
     // absFile now points to "/local/bin",
     // while relFile points to "/tmp/local/bin"
     \endcode
 
     \sa isRelative(), QDir::setCurrent(), QDir::isRelativePath()
 */
 
 void QFileInfo::setFile( const QString &file )
 {
     fn = file;
     slashify( fn );
     delete fic;
     fic = 0;
 }
 
 /*!
     \overload
 
     Sets the file that the QFileInfo provides information about to \a
     file.
 
     If \a file includes a relative path, the QFileInfo will also have
     a relative path.
 
     \sa isRelative()
 */
 
 void QFileInfo::setFile( const QFile &file )
 {
     fn	= file.name();
     slashify( fn );
     delete fic;
     fic = 0;
 }
 
 /*!
     \overload
 
     Sets the file that the QFileInfo provides information about to \a
     fileName in directory \a d.
 
     If \a fileName includes a relative path, the QFileInfo will also
     have a relative path.
 
     \sa isRelative()
 */
 #ifndef QT_NO_DIR
 void QFileInfo::setFile( const QDir &d, const QString &fileName )
 {
     fn	= d.filePath( fileName );
     slashify( fn );
     delete fic;
     fic = 0;
 }
 #endif
 
 /*!
     Returns TRUE if the file exists; otherwise returns FALSE.
 */
 
 bool QFileInfo::exists() const
 {
     return qt_file_access( fn, F_OK );
 }
 
 /*!
     Refreshes the information about the file, i.e. reads in information
     from the file system the next time a cached property is fetched.
 
     \sa setCaching()
 */
 
 void QFileInfo::refresh() const
 {
     QFileInfo *that = (QFileInfo*)this;		// Mutable function
     delete that->fic;
     that->fic = 0;
 }
 
 /*!
     \fn bool QFileInfo::caching() const
 
     Returns TRUE if caching is enabled; otherwise returns FALSE.
 
     \sa setCaching(), refresh()
 */
 
 /*!
     If \a enable is TRUE, enables caching of file information. If \a
     enable is FALSE caching is disabled.
 
     When caching is enabled, QFileInfo reads the file information from
     the file system the first time it's needed, but generally not
     later.
 
     Caching is enabled by default.
 
     \sa refresh(), caching()
 */
 
 void QFileInfo::setCaching( bool enable )
 {
     if ( cache == enable )
 	return;
     cache = enable;
     if ( cache ) {
 	delete fic;
 	fic = 0;
     }
 }
 
 
 /*!
     Returns the file name, including the path (which may be absolute
     or relative).
 
     \sa isRelative(), absFilePath()
 */
 
 QString QFileInfo::filePath() const
 {
     return fn;
 }
 
 /*!
     Returns the base name of the file.
 
     If \a complete is FALSE (the default) the base name consists of
     all characters in the file name up to (but not including) the \e
     first '.' character.
 
     If \a complete is TRUE the base name consists of all characters in
     the file up to (but not including) the \e last '.' character.
 
     The path is not included in either case.
 
     Example:
     \code
 	QFileInfo fi( "/tmp/archive.tar.gz" );
 	QString base = fi.baseName();  // base = "archive"
 	base = fi.baseName( TRUE );    // base = "archive.tar"
     \endcode
 
     \sa fileName(), extension()
 */
 
 QString QFileInfo::baseName( bool complete ) const
 {
     QString tmp = fileName();
     int pos = complete ? tmp.findRev( '.' ) : tmp.find( '.' );
     if ( pos == -1 )
 	return tmp;
     else
 	return tmp.left( pos );
 }
 
 /*!
     Returns the file's extension name.
 
     If \a complete is TRUE (the default), extension() returns the
     string of all characters in the file name after (but not
     including) the first '.'  character.
 
     If \a complete is FALSE, extension() returns the string of all
     characters in the file name after (but not including) the last '.'
     character.
 
     Example:
     \code
 	QFileInfo fi( "/tmp/archive.tar.gz" );
 	QString ext = fi.extension();  // ext = "tar.gz"
 	ext = fi.extension( FALSE );   // ext = "gz"
     \endcode
 
     \sa fileName(), baseName()
 */
 
 QString QFileInfo::extension( bool complete ) const
 {
     QString s = fileName();
     int pos = complete ? s.find( '.' ) : s.findRev( '.' );
     if ( pos < 0 )
 	return QString::fromLatin1( "" );
     else
 	return s.right( s.length() - pos - 1 );
 }
 
 /*!
     Returns the file's path as a QDir object.
 
     If the QFileInfo is relative and \a absPath is FALSE, the QDir
     will be relative; otherwise it will be absolute.
 
     \sa dirPath(), filePath(), fileName(), isRelative()
 */
 #ifndef QT_NO_DIR
 QDir QFileInfo::dir( bool absPath ) const
 {
     return QDir( dirPath(absPath) );
 }
 #endif
 
 
 /*!
     Returns TRUE if the file is readable; otherwise returns FALSE.
 
     \sa isWritable(), isExecutable(), permission()
 */
 
 bool QFileInfo::isReadable() const
 {
     return qt_file_access( fn, R_OK ) && permission( ReadUser );
 }
 
 /*!
     Returns TRUE if the file is writable; otherwise returns FALSE.
 
     \sa isReadable(), isExecutable(), permission()
 */
 
 bool QFileInfo::isWritable() const
 {
     return qt_file_access( fn, W_OK ) && permission( WriteUser );
 }
 
 /*!
     Returns TRUE if the file is executable; otherwise returns FALSE.
 
     \sa isReadable(), isWritable(), permission()
 */
 
 bool QFileInfo::isExecutable() const
 {
     return qt_file_access( fn, X_OK ) && permission( ExeUser );
 }
 
 #ifndef Q_WS_WIN
 bool QFileInfo::isHidden() const
 {
     return fileName()[ 0 ] == QChar( '.' );
 }
 #endif
 
 /*!
     Returns TRUE if the file path name is relative. Returns FALSE if
     the path is absolute (e.g. under Unix a path is absolute if it
     begins with a "/").
 */
 #ifndef QT_NO_DIR
 bool QFileInfo::isRelative() const
 {
     return QDir::isRelativePath( fn );
 }
 
 /*!
     Converts the file's path to an absolute path.
 
     If it is already absolute, nothing is done.
 
     \sa filePath(), isRelative()
 */
 
 bool QFileInfo::convertToAbs()
 {
     if ( isRelative() )
 	fn = absFilePath();
     return QDir::isRelativePath( fn );
 }
 #endif
 
 /*!
     Returns the file size in bytes, or 0 if the file does not exist or
     if the size is 0 or if the size cannot be fetched.
 */
 #if defined(QT_ABI_QT4)
 QIODevice::Offset QFileInfo::size() const
 #else
 uint QFileInfo::size() const
 #endif
 {
     if ( !fic || !cache )
 	doStat();
     if ( fic )
 #if defined(QT_ABI_QT4)
 	return (QIODevice::Offset)fic->st.st_size;
 #elif defined(QT_LARGEFILE_SUPPORT)
 	return (uint)fic->st.st_size > UINT_MAX ? UINT_MAX : (uint)fic->st.st_size;
 #else
 	return (uint)fic->st.st_size;
 #endif
     else
 	return 0;
 }
 
 /*!
     Returns the date and time when the file was created.
 
     On platforms where this information is not available, returns the
     same as lastModified().
 
     \sa created() lastModified() lastRead()
 */
 
 QDateTime QFileInfo::created() const
 {
     QDateTime dt;
     if ( !fic || !cache )
 	doStat();
     if ( fic && fic->st.st_ctime != 0 ) {
 	dt.setTime_t( fic->st.st_ctime );
 	return dt;
     } else {
 	return lastModified();
     }
 }
 
 /*!
     Returns the date and time when the file was last modified.
 
     \sa created() lastModified() lastRead()
 */
 
 QDateTime QFileInfo::lastModified() const
 {
     QDateTime dt;
     if ( !fic || !cache )
 	doStat();
     if ( fic )
 	dt.setTime_t( fic->st.st_mtime );
     return dt;
 }
 
 /*!
     Returns the date and time when the file was last read (accessed).
 
     On platforms where this information is not available, returns the
     same as lastModified().
 
     \sa created() lastModified() lastRead()
 */
 
 QDateTime QFileInfo::lastRead() const
 {
     QDateTime dt;
     if ( !fic || !cache )
 	doStat();
     if ( fic && fic->st.st_atime != 0 ) {
 	dt.setTime_t( fic->st.st_atime );
 	return dt;
     } else {
 	return lastModified();
     }
 }
 
 #ifndef QT_NO_DIR
 
 /*!
     Returns the absolute path including the file name.
 
     The absolute path name consists of the full path and the file
     name. On Unix this will always begin with the root, '/',
     directory. On Windows this will always begin 'D:/' where D is a
     drive letter, except for network shares that are not mapped to a
     drive letter, in which case the path will begin '//sharename/'.
 
     This function returns the same as filePath(), unless isRelative()
     is TRUE.
 
+    If the QFileInfo is empty it returns QDir::currentDirPath().
+
     This function can be time consuming under Unix (in the order of
     milliseconds).
 
     \sa isRelative(), filePath()
 */
 QString QFileInfo::absFilePath() const
 {
     QString tmp;
     if ( QDir::isRelativePath(fn)
-#if defined(Q_OS_WIN32) || defined(Q_OS_WIN64)
+#if defined(Q_OS_WIN32)
 	 && fn[1] != ':'
 #endif
 	 ) {
 	tmp = QDir::currentDirPath();
 	tmp += '/';
     }
     tmp += fn;
     makeAbs( tmp );
     return QDir::cleanDirPath( tmp );
 }
 
 #endif
diff --git a/qmake/tools/qfileinfo_unix.cpp b/qmake/tools/qfileinfo_unix.cpp
index f7c3a97..364f219 100644
--- a/qmake/tools/qfileinfo_unix.cpp
+++ b/qmake/tools/qfileinfo_unix.cpp
@@ -1,331 +1,331 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QFileInfo class
 **
 ** Created : 950628
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses for Unix/X11 or for Qt/Embedded may use this file in accordance
 ** with the Qt Commercial License Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qplatformdefs.h"
 #include "qfileinfo.h"
 #include "qfiledefs_p.h"
 #include "qdatetime.h"
 #include "qdir.h"
 
 #include <limits.h>
 
 
 void QFileInfo::slashify( QString& )
 {
     return;
 }
 
 
 void QFileInfo::makeAbs( QString & )
 {
     return;
 }
 
 /*!
     Returns TRUE if this object points to a file. Returns FALSE if the
     object points to something which isn't a file, e.g. a directory or
     a symlink.
 
     \sa isDir(), isSymLink()
 */
 bool QFileInfo::isFile() const
 {
     if ( !fic || !cache )
 	doStat();
     return fic ? (fic->st.st_mode & S_IFMT) == S_IFREG : FALSE;
 }
 
 /*!
     Returns TRUE if this object points to a directory or to a symbolic
     link to a directory; otherwise returns FALSE.
 
     \sa isFile(), isSymLink()
 */
 bool QFileInfo::isDir() const
 {
     if ( !fic || !cache )
 	doStat();
     return fic ? (fic->st.st_mode & S_IFMT) == S_IFDIR : FALSE;
 }
 
 /*!
     Returns TRUE if this object points to a symbolic link (or to a
     shortcut on Windows); otherwise returns FALSE.
 
     \sa isFile(), isDir(), readLink()
 */
 
 bool QFileInfo::isSymLink() const
 {
     if ( !fic || !cache )
 	doStat();
     return symLink;
 }
 
 /*!
     Returns the name a symlink (or shortcut on Windows) points to, or
     a QString::null if the object isn't a symbolic link.
 
     This name may not represent an existing file; it is only a string.
     QFileInfo::exists() returns TRUE if the symlink points to an
     existing file.
 
     \sa exists(), isSymLink(), isDir(), isFile()
 */
 
 QString QFileInfo::readLink() const
 {
     QString r;
 
 #if defined(Q_OS_UNIX) && !defined(Q_OS_OS2EMX)
     char s[PATH_MAX+1];
     if ( !isSymLink() )
 	return QString();
     int len = readlink( QFile::encodeName(fn).data(), s, PATH_MAX );
     if ( len >= 0 ) {
 	s[len] = '\0';
 	r = QFile::decodeName(s);
     }
 #endif
 
     return r;
 }
 
 static const uint nobodyID = (uint) -2;
 
 /*!
     Returns the owner of the file. On Windows, on systems where files
     do not have owners, or if an error occurs, QString::null is
     returned.
 
     This function can be time consuming under Unix (in the order of
     milliseconds).
 
     \sa ownerId(), group(), groupId()
 */
 
 QString QFileInfo::owner() const
 {
     passwd *pw = getpwuid( ownerId() );
     if ( pw )
 	return QFile::decodeName( pw->pw_name );
     return QString::null;
 }
 
 /*!
     Returns the id of the owner of the file.
 
     On Windows and on systems where files do not have owners this
     function returns ((uint) -2).
 
     \sa owner(), group(), groupId()
 */
 
 uint QFileInfo::ownerId() const
 {
     if ( !fic || !cache )
 	doStat();
     if ( fic )
 	return fic->st.st_uid;
     return nobodyID;
 }
 
 /*!
     Returns the group of the file. On Windows, on systems where files
     do not have groups, or if an error occurs, QString::null is
     returned.
 
     This function can be time consuming under Unix (in the order of
     milliseconds).
 
     \sa groupId(), owner(), ownerId()
 */
 
 QString QFileInfo::group() const
 {
     struct group *gr = getgrgid( groupId() );
     if ( gr )
 	return QFile::decodeName( gr->gr_name );
     return QString::null;
 }
 
 /*!
     Returns the id of the group the file belongs to.
 
     On Windows and on systems where files do not have groups this
     function always returns (uint) -2.
 
     \sa group(), owner(), ownerId()
 */
 
 uint QFileInfo::groupId() const
 {
     if ( !fic || !cache )
 	doStat();
     if ( fic )
 	return fic->st.st_gid;
     return nobodyID;
 }
 
 
 /*!
     Tests for file permissions. The \a permissionSpec argument can be
     several flags of type \c PermissionSpec OR-ed together to check
     for permission combinations.
 
     On systems where files do not have permissions this function
     always returns TRUE.
 
     Example:
     \code
 	QFileInfo fi( "/tmp/archive.tar.gz" );
 	if ( fi.permission( QFileInfo::WriteUser | QFileInfo::ReadGroup ) )
-	    qWarning( "I can change the file; my group can read the file.");
+	    qWarning( "I can change the file; my group can read the file" );
 	if ( fi.permission( QFileInfo::WriteGroup | QFileInfo::WriteOther ) )
-	    qWarning( "The group or others can change the file!" );
+	    qWarning( "The group or others can change the file" );
     \endcode
 
     \sa isReadable(), isWritable(), isExecutable()
 */
 
 bool QFileInfo::permission( int permissionSpec ) const
 {
     if ( !fic || !cache )
 	doStat();
     if ( fic ) {
 	uint mask = 0;
 	if ( permissionSpec & ReadUser )
 	    mask |= S_IRUSR;
 	if ( permissionSpec & WriteUser )
 	    mask |= S_IWUSR;
 	if ( permissionSpec & ExeUser )
 	    mask |= S_IXUSR;
 	if ( permissionSpec & ReadGroup )
 	    mask |= S_IRGRP;
 	if ( permissionSpec & WriteGroup )
 	    mask |= S_IWGRP;
 	if ( permissionSpec & ExeGroup )
 	    mask |= S_IXGRP;
 	if ( permissionSpec & ReadOther )
 	    mask |= S_IROTH;
 	if ( permissionSpec & WriteOther )
 	    mask |= S_IWOTH;
 	if ( permissionSpec & ExeOther )
 	    mask |= S_IXOTH;
 	if ( mask ) {
 	   return (fic->st.st_mode & mask) == mask;
 	} else {
 #if defined(QT_CHECK_NULL)
 	   qWarning( "QFileInfo::permission: permissionSpec is 0" );
 #endif
 	   return TRUE;
 	}
     } else {
 	return FALSE;
     }
 }
 
 void QFileInfo::doStat() const
 {
     QFileInfo *that = ((QFileInfo*)this);	// mutable function
     if ( !that->fic )
 	that->fic = new QFileInfoCache;
     that->symLink = FALSE;
     struct stat *b = &that->fic->st;
 #if defined(Q_OS_UNIX) && defined(S_IFLNK)
     if ( ::lstat( QFile::encodeName(fn), b ) == 0 ) {
 	if ( S_ISLNK( b->st_mode ) )
 	    that->symLink = TRUE;
 	else
 	    return;
     }
 #endif
 
     int r = ::stat( QFile::encodeName(fn), b );
     if ( r != 0 && !that->symLink ) {
 	delete that->fic;
 	that->fic = 0;
     }
 }
 
 /*!
     Returns the file's path.
 
     If \a absPath is TRUE an absolute path is returned.
 
     \sa dir(), filePath(), fileName(), isRelative()
 */
 #ifndef QT_NO_DIR
 QString QFileInfo::dirPath( bool absPath ) const
 {
     QString s;
     if ( absPath )
 	s = absFilePath();
     else
 	s = fn;
     int pos = s.findRev( '/' );
     if ( pos == -1 ) {
 	return QString::fromLatin1( "." );
     } else {
 	if ( pos == 0 )
 	    return QString::fromLatin1( "/" );
 	return s.left( pos );
     }
 }
 #endif
 
 /*!
     Returns the name of the file, excluding the path.
 
     Example:
     \code
 	QFileInfo fi( "/tmp/archive.tar.gz" );
 	QString name = fi.fileName();		// name = "archive.tar.gz"
     \endcode
 
     \sa isRelative(), filePath(), baseName(), extension()
 */
 
 QString QFileInfo::fileName() const
 {
     int p = fn.findRev( '/' );
     if ( p == -1 ) {
 	return fn;
     } else {
 	return fn.mid( p + 1 );
     }
 }
diff --git a/qmake/tools/qgarray.cpp b/qmake/tools/qgarray.cpp
index 45c45ce..0a522e4 100644
--- a/qmake/tools/qgarray.cpp
+++ b/qmake/tools/qgarray.cpp
@@ -1,754 +1,817 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QGArray class
 **
 ** Created : 930906
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
-#include "qglobal.h"			// needed to define Q_WS_WIN
-#ifdef Q_WS_WIN
-#include "qt_windows.h"			// needed for bsearch on some platforms
+#include "qglobal.h"
+#if defined(Q_CC_BOR)
+    // needed for qsort() because of a std namespace problem on Borland
+#   include "qplatformdefs.h"
+#elif defined(Q_WS_WIN)
+    // needed for bsearch on some platforms
+#   include "qt_windows.h"
 #endif
 
 #define	 QGARRAY_CPP
 #include "qgarray.h"
 #include <stdlib.h>
 #include <string.h>
 
 #ifdef QT_THREAD_SUPPORT
 #  include <private/qmutexpool_p.h>
 #endif // QT_THREAD_SUPPORT
 
-#define USE_MALLOC				// comment to use new/delete
+/*
+  If USE_MALLOC isn't defined, we use new[] and delete[] to allocate
+  memory. The documentation for QMemArray<T>::assign() explicitly
+  mentions that the array is freed using free(), so don't mess around
+  with USE_MALLOC unless you know what you're doing.
+*/
+#define USE_MALLOC
 
 #undef NEW
 #undef DELETE
 
 #if defined(USE_MALLOC)
 #define NEW(type,size)	((type*)malloc(size*sizeof(type)))
 #define DELETE(array)	(free((char*)array))
 #else
 #define NEW(type,size)	(new type[size])
 #define DELETE(array)	(delete[] array)
 #define DONT_USE_REALLOC			// comment to use realloc()
 #endif
 
 /*!
   \class QShared qshared.h
   \reentrant
   \ingroup shared
   \brief The QShared class is used internally for implementing shared classes.
 
   \internal
 
   It only contains a reference count and member functions to increment and
   decrement it.
 
   Shared classes normally have internal classes that inherit QShared and
   add the shared data.
 
   \sa \link shclass.html Shared Classes\endlink
 */
 
 /*!
   \class QGArray qgarray.h
   \reentrant
   \ingroup shared
   \ingroup collection
   \brief The QGArray class is an internal class for implementing the QMemArray class.
 
   \internal
 
   QGArray is a strictly internal class that acts as base class for the
   QMemArray template array.
 
   It contains an array of bytes and has no notion of an array element.
 */
 
 
 /*!
   Constructs a null array.
 */
 
 QGArray::QGArray()
 {
     shd = newData();
     Q_CHECK_PTR( shd );
 }
 
 /*!
   Dummy constructor; does not allocate any data.
 
   This constructor does not initialize any array data so subclasses
   must do it. The intention is to make the code more efficient.
 */
 
 QGArray::QGArray( int, int )
 {
 }
 
 /*!
   Constructs an array with room for \a size bytes.
 */
 
 QGArray::QGArray( int size )
 {
     if ( size < 0 ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "QGArray: Cannot allocate array with negative length" );
 #endif
 	size = 0;
     }
     shd = newData();
     Q_CHECK_PTR( shd );
     if ( size == 0 )				// zero length
 	return;
     shd->data = NEW(char,size);
     Q_CHECK_PTR( shd->data );
-    shd->len = size;
+    shd->len =
+#ifdef QT_QGARRAY_SPEED_OPTIM
+	shd->maxl =
+#endif
+	size;
 }
 
 /*!
   Constructs a shallow copy of \a a.
 */
 
 QGArray::QGArray( const QGArray &a )
 {
     shd = a.shd;
     shd->ref();
 }
 
 /*!
   Dereferences the array data and deletes it if this was the last
   reference.
 */
 
 QGArray::~QGArray()
 {
     if ( shd && shd->deref() ) {		// delete when last reference
 	if ( shd->data )			// is lost
 	    DELETE(shd->data);
 	deleteData( shd );
 	shd = 0;
     }
 }
 
 
 /*!
   \fn QGArray &QGArray::operator=( const QGArray &a )
 
   Assigns a shallow copy of \a a to this array and returns a reference to
   this array.  Equivalent to assign().
 */
 
 /*!
   \fn void QGArray::detach()
 
   Detaches this array from shared array data.
 */
 
 /*!
   \fn char *QGArray::data() const
 
   Returns a pointer to the actual array data.
 */
 
 /*!
   \fn uint QGArray::nrefs() const
 
   Returns the reference count.
 */
 
 /*!
   \fn uint QGArray::size() const
 
   Returns the size of the array, in bytes.
 */
 
 
 /*!
   Returns TRUE if this array is equal to \a a, otherwise FALSE.
   The comparison is bitwise, of course.
 */
 
 bool QGArray::isEqual( const QGArray &a ) const
 {
     if ( size() != a.size() )			// different size
 	return FALSE;
     if ( data() == a.data() )			// has same data
 	return TRUE;
     return (size() ? memcmp( data(), a.data(), size() ) : 0) == 0;
 }
 
 
 /*!
-  Resizes the array to \a newsize bytes.
+  Resizes the array to \a newsize bytes. \a optim is either
+  MemOptim (the default) or SpeedOptim.
 */
-
-bool QGArray::resize( uint newsize )
+bool QGArray::resize( uint newsize, Optimization optim )
 {
-    if ( newsize == shd->len )			// nothing to do
+#ifndef QT_QGARRAY_SPEED_OPTIM
+    Q_UNUSED(optim);
+#endif
+
+    if ( newsize == shd->len
+#ifdef QT_QGARRAY_SPEED_OPTIM
+	 && newsize == shd->maxl
+#endif
+	) // nothing to do
 	return TRUE;
     if ( newsize == 0 ) {			// remove array
 	duplicate( 0, 0 );
 	return TRUE;
     }
+
+    uint newmaxl = newsize;
+#ifdef QT_QGARRAY_SPEED_OPTIM
+    if ( optim == SpeedOptim ) {
+	if ( newsize <= shd->maxl &&
+	     ( newsize * 4 > shd->maxl || shd->maxl <= 4 ) ) {
+	    shd->len = newsize;
+	    return TRUE;
+	}
+	newmaxl = 4;
+	while ( newmaxl < newsize )
+	    newmaxl *= 2;
+	// try to spare some memory
+	if ( newmaxl >= 1024 * 1024 && newsize <= newmaxl - (newmaxl >> 2) )
+	    newmaxl -= newmaxl >> 2;
+    }
+    shd->maxl = newmaxl;
+#endif
+
     if ( shd->data ) {				// existing data
 #if defined(DONT_USE_REALLOC)
 	char *newdata = NEW(char,newsize);	// manual realloc
-	memcpy( newdata, shd->data, QMIN(shd->len,newsize) );
+	memcpy( newdata, shd->data, QMIN(shd->len,newmaxl) );
 	DELETE(shd->data);
 	shd->data = newdata;
 #else
-	shd->data = (char *)realloc( shd->data, newsize );
+	shd->data = (char *)realloc( shd->data, newmaxl );
 #endif
     } else {
-	shd->data = NEW(char,newsize);
+	shd->data = NEW(char,newmaxl);
     }
     if ( !shd->data )				// no memory
 	return FALSE;
     shd->len = newsize;
     return TRUE;
 }
 
+/*!\overload
+*/
+bool QGArray::resize( uint newsize )
+{
+    return resize( newsize, MemOptim );
+}
+
+
 /*!
   Fills the array with the repeated occurrences of \a d, which is
   \a sz bytes long.
   If \a len is specified as different from -1, then the array will be
   resized to \a len*sz before it is filled.
 
   Returns TRUE if successful, or FALSE if the memory cannot be allocated
   (only when \a len != -1).
 
   \sa resize()
 */
 
 bool QGArray::fill( const char *d, int len, uint sz )
 {
     if ( len < 0 )
 	len = shd->len/sz;			// default: use array length
     else if ( !resize( len*sz ) )
 	return FALSE;
     if ( sz == 1 )				// 8 bit elements
 	memset( data(), *d, len );
     else if ( sz == 4 ) {			// 32 bit elements
 	register Q_INT32 *x = (Q_INT32*)data();
 	Q_INT32 v = *((Q_INT32*)d);
 	while ( len-- )
 	    *x++ = v;
     } else if ( sz == 2 ) {			// 16 bit elements
 	register Q_INT16 *x = (Q_INT16*)data();
 	Q_INT16 v = *((Q_INT16*)d);
 	while ( len-- )
 	    *x++ = v;
     } else {					// any other size elements
 	register char *x = data();
 	while ( len-- ) {			// more complicated
 	    memcpy( x, d, sz );
 	    x += sz;
 	}
     }
     return TRUE;
 }
 
 /*!
     \overload
   Shallow copy. Dereference the current array and references the data
   contained in \a a instead. Returns a reference to this array.
   \sa operator=()
 */
 
 QGArray &QGArray::assign( const QGArray &a )
 {
     a.shd->ref();				// avoid 'a = a'
     if ( shd->deref() ) {			// delete when last reference
 	if ( shd->data )			// is lost
 	    DELETE(shd->data);
 	deleteData( shd );
     }
     shd = a.shd;
     return *this;
 }
 
 /*!
   Shallow copy. Dereference the current array and references the
   array data \a d, which contains \a len bytes.
   Returns a reference to this array.
 
   Do not delete \a d later, because QGArray takes care of that.
 */
 
 QGArray &QGArray::assign( const char *d, uint len )
 {
     if ( shd->count > 1 ) {			// disconnect this
 	shd->count--;
 	shd = newData();
 	Q_CHECK_PTR( shd );
     } else {
 	if ( shd->data )
 	    DELETE(shd->data);
     }
     shd->data = (char *)d;
-    shd->len = len;
+    shd->len =
+#ifdef QT_QGARRAY_SPEED_OPTIM
+	shd->maxl =
+#endif
+	len;
     return *this;
 }
 
 /*!
   Deep copy. Dereference the current array and obtains a copy of the data
   contained in \a a instead. Returns a reference to this array.
   \sa assign(), operator=()
 */
 
 QGArray &QGArray::duplicate( const QGArray &a )
 {
     if ( a.shd == shd ) {			// a.duplicate(a) !
 	if ( shd->count > 1 ) {
 	    shd->count--;
 	    register array_data *n = newData();
 	    Q_CHECK_PTR( n );
 	    if ( (n->len=shd->len) ) {
 		n->data = NEW(char,n->len);
 		Q_CHECK_PTR( n->data );
 		if ( n->data )
 		    memcpy( n->data, shd->data, n->len );
 	    } else {
 		n->data = 0;
 	    }
 	    shd = n;
 	}
 	return *this;
     }
     char *oldptr = 0;
     if ( shd->count > 1 ) {			// disconnect this
 	shd->count--;
 	shd = newData();
 	Q_CHECK_PTR( shd );
     } else {					// delete after copy was made
 	oldptr = shd->data;
     }
     if ( a.shd->len ) {				// duplicate data
 	shd->data = NEW(char,a.shd->len);
 	Q_CHECK_PTR( shd->data );
 	if ( shd->data )
 	    memcpy( shd->data, a.shd->data, a.shd->len );
     } else {
 	shd->data = 0;
     }
-    shd->len = a.shd->len;
+    shd->len =
+#ifdef QT_QGARRAY_SPEED_OPTIM
+	shd->maxl =
+#endif
+	a.shd->len;
     if ( oldptr )
 	DELETE(oldptr);
     return *this;
 }
 
 /*!
     \overload
   Deep copy. Dereferences the current array and obtains a copy of
   \a len characters from array data \a d instead.  Returns a reference
   to this array.
   \sa assign(), operator=()
 */
 
 QGArray &QGArray::duplicate( const char *d, uint len )
 {
     char *data;
     if ( d == 0 || len == 0 ) {
 	data = 0;
 	len  = 0;
     } else {
 	if ( shd->count == 1 && shd->len == len ) {
 	    memcpy( shd->data, d, len );	// use same buffer
 	    return *this;
 	}
 	data = NEW(char,len);
 	Q_CHECK_PTR( data );
 	memcpy( data, d, len );
     }
     if ( shd->count > 1 ) {			// detach
 	shd->count--;
 	shd = newData();
 	Q_CHECK_PTR( shd );
     } else {					// just a single reference
 	if ( shd->data )
 	    DELETE(shd->data);
     }
     shd->data = data;
-    shd->len  = len;
+    shd->len =
+#ifdef QT_QGARRAY_SPEED_OPTIM
+	shd->maxl =
+#endif
+	len;
     return *this;
 }
 
 /*!
   Resizes this array to \a len bytes and copies the \a len bytes at
   address \a d into it.
 
   \warning This function disregards the reference count mechanism.  If
   other QGArrays reference the same data as this, all will be updated.
 */
 
 void QGArray::store( const char *d, uint len )
 {						// store, but not deref
     resize( len );
     memcpy( shd->data, d, len );
 }
 
 
 /*!
   \fn array_data *QGArray::sharedBlock() const
 
   Returns a pointer to the shared array block.
 
   \warning
 
   Do not use this function.  Using it is begging for trouble.  We dare
   not remove it, for fear of breaking code, but we \e strongly
   discourage new use of it.
 */
 
 /*!
   \fn void QGArray::setSharedBlock( array_data *p )
 
   Sets the shared array block to \a p.
 
   \warning
 
   Do not use this function.  Using it is begging for trouble.  We dare
   not remove it, for fear of breaking code, but we \e strongly
   discourage new use of it.
 */
 
 
 /*!
   Sets raw data and returns a reference to the array.
 
   Dereferences the current array and sets the new array data to \a d and
   the new array size to \a len.	 Do not attempt to resize or re-assign the
   array data when raw data has been set.
   Call resetRawData(d,len) to reset the array.
 
   Setting raw data is useful because it sets QMemArray data without
   allocating memory or copying data.
 
   Example of intended use:
   \code
     static uchar bindata[] = { 231, 1, 44, ... };
     QByteArray	a;
     a.setRawData( bindata, sizeof(bindata) );	// a points to bindata
     QDataStream s( a, IO_ReadOnly );		// open on a's data
     s >> <something>;				// read raw bindata
     s.close();
     a.resetRawData( bindata, sizeof(bindata) ); // finished
   \endcode
 
   Example of misuse (do not do this):
   \code
     static uchar bindata[] = { 231, 1, 44, ... };
     QByteArray	a, b;
     a.setRawData( bindata, sizeof(bindata) );	// a points to bindata
     a.resize( 8 );				// will crash
     b = a;					// will crash
     a[2] = 123;					// might crash
       // forget to resetRawData - will crash
   \endcode
 
   \warning If you do not call resetRawData(), QGArray will attempt to
   deallocate or reallocate the raw data, which might not be too good.
   Be careful.
 */
 
 QGArray &QGArray::setRawData( const char *d, uint len )
 {
     duplicate( 0, 0 );				// set null data
     shd->data = (char *)d;
     shd->len  = len;
     return *this;
 }
 
 /*!
   Resets raw data.
 
   The arguments must be the data, \a d, and length \a len, that were
   passed to setRawData().  This is for consistency checking.
 */
 
 void QGArray::resetRawData( const char *d, uint len )
 {
     if ( d != shd->data || len != shd->len ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QGArray::resetRawData: Inconsistent arguments" );
 #endif
 	return;
     }
     shd->data = 0;
     shd->len  = 0;
 }
 
 
 /*!
   Finds the first occurrence of \a d in the array from position \a index,
   where \a sz is the size of the \a d element.
 
   Note that \a index is given in units of \a sz, not bytes.
 
   This function only compares whole cells, not bytes.
 */
 
 int QGArray::find( const char *d, uint index, uint sz ) const
 {
     index *= sz;
     if ( index >= shd->len ) {
 #if defined(QT_CHECK_RANGE)
 	qWarning( "QGArray::find: Index %d out of range", index/sz );
 #endif
 	return -1;
     }
     register uint i;
     uint ii;
     switch ( sz ) {
 	case 1: {				// 8 bit elements
 	    register char *x = data() + index;
 	    char v = *d;
 	    for ( i=index; i<shd->len; i++ ) {
 		if ( *x++ == v )
 		    break;
 	    }
 	    ii = i;
 	    }
 	    break;
 	case 2: {				// 16 bit elements
 	    register Q_INT16 *x = (Q_INT16*)(data() + index);
 	    Q_INT16 v = *((Q_INT16*)d);
 	    for ( i=index; i<shd->len; i+=2 ) {
 		if ( *x++ == v )
 		    break;
 	    }
 	    ii = i/2;
 	    }
 	    break;
 	case 4: {				// 32 bit elements
 	    register Q_INT32 *x = (Q_INT32*)(data() + index);
 	    Q_INT32 v = *((Q_INT32*)d);
 	    for ( i=index; i<shd->len; i+=4 ) {
 		if ( *x++ == v )
 		    break;
 	    }
 	    ii = i/4;
 	    }
 	    break;
 	default: {				// any size elements
 	    for ( i=index; i<shd->len; i+=sz ) {
 		if ( memcmp( d, &shd->data[i], sz ) == 0 )
 		    break;
 	    }
 	    ii = i/sz;
 	    }
 	    break;
     }
     return i<shd->len ? (int)ii : -1;
 }
 
 /*!
   Returns the number of occurrences of \a d in the array, where \a sz is
   the size of the \a d element.
 
   This function only compares whole cells, not bytes.
 */
 
 int QGArray::contains( const char *d, uint sz ) const
 {
     register uint i = shd->len;
     int count = 0;
     switch ( sz ) {
 	case 1: {				// 8 bit elements
 	    register char *x = data();
 	    char v = *d;
 	    while ( i-- ) {
 		if ( *x++ == v )
 		    count++;
 	    }
 	    }
 	    break;
 	case 2: {				// 16 bit elements
 	    register Q_INT16 *x = (Q_INT16*)data();
 	    Q_INT16 v = *((Q_INT16*)d);
 	    i /= 2;
 	    while ( i-- ) {
 		if ( *x++ == v )
 		    count++;
 	    }
 	    }
 	    break;
 	case 4: {				// 32 bit elements
 	    register Q_INT32 *x = (Q_INT32*)data();
 	    Q_INT32 v = *((Q_INT32*)d);
 	    i /= 4;
 	    while ( i-- ) {
 		if ( *x++ == v )
 		    count++;
 	    }
 	    }
 	    break;
 	default: {				// any size elements
 	    for ( i=0; i<shd->len; i+=sz ) {
 		if ( memcmp(d, &shd->data[i], sz) == 0 )
 		    count++;
 	    }
 	    }
 	    break;
     }
     return count;
 }
 
 static int cmp_item_size = 0;
 
 #if defined(Q_C_CALLBACKS)
 extern "C" {
 #endif
 
 #ifdef Q_OS_TEMP
 static int __cdecl cmp_arr( const void *n1, const void *n2 )
 #else
 static int cmp_arr( const void *n1, const void *n2 )
 #endif
 {
     return ( n1 && n2 ) ? memcmp( n1, n2, cmp_item_size )
 			: ( n1 ? 1 : ( n2 ? -1 : 0 ) );
     // ### Qt 3.0: Add a virtual compareItems() method and call that instead
 }
 
 #if defined(Q_C_CALLBACKS)
 }
 #endif
 
 /*!
   Sorts the first \a sz items of the array.
 */
 
 void QGArray::sort( uint sz )
 {
     int numItems = size() / sz;
     if ( numItems < 2 )
 	return;
 
 #ifdef QT_THREAD_SUPPORT
-    QMutexLocker locker( qt_global_mutexpool->get( &cmp_item_size ) );
+    QMutexLocker locker( qt_global_mutexpool ?
+			 qt_global_mutexpool->get( &cmp_item_size ) : 0 );
 #endif // QT_THREAD_SUPPORT
 
     cmp_item_size = sz;
     qsort( shd->data, numItems, sz, cmp_arr );
 }
 
 /*!
   Binary search; assumes that \a d is a sorted array of size \a sz.
 */
 
 int QGArray::bsearch( const char *d, uint sz ) const
 {
     int numItems = size() / sz;
     if ( !numItems )
 	return -1;
 
 #ifdef QT_THREAD_SUPPORT
-    QMutexLocker locker( qt_global_mutexpool->get( &cmp_item_size ) );
+    QMutexLocker locker( qt_global_mutexpool ?
+			 qt_global_mutexpool->get( &cmp_item_size ) : 0 );
 #endif // QT_THREAD_SUPPORT
 
     cmp_item_size = sz;
     char* r = (char*)::bsearch( d, shd->data, numItems, sz, cmp_arr );
     if ( !r )
 	return -1;
     while( (r >= shd->data + sz) && (cmp_arr( r - sz, d ) == 0) )
 	r -= sz;	// search to first of equal elements; bsearch is undef
     return (int)(( r - shd->data ) / sz);
 }
 
 
 /*!
   \fn char *QGArray::at( uint index ) const
 
   Returns a pointer to the byte at offset \a index in the array.
 */
 
 /*!
   Expand the array if necessary, and copies (the first part of) its
   contents from the \a index * \a sz bytes at \a d.
 
   Returns TRUE if the operation succeeds, FALSE if it runs out of
   memory.
 
   \warning This function disregards the reference count mechanism.  If
   other QGArrays reference the same data as this, all will be changed.
 */
 
 bool QGArray::setExpand( uint index, const char *d, uint sz )
 {
     index *= sz;
     if ( index >= shd->len ) {
 	if ( !resize( index+sz ) )		// no memory
 	    return FALSE;
     }
     memcpy( data() + index, d, sz );
     return TRUE;
 }
 
 
 /*!
   Prints a warning message if at() or [] is given a bad index.
 */
 
 void QGArray::msg_index( uint index )
 {
 #if defined(QT_CHECK_RANGE)
     qWarning( "QGArray::at: Absolute index %d out of range", index );
 #else
     Q_UNUSED( index )
 #endif
 }
 
 
 /*!
   Returns a new shared array block.
 */
 
 QGArray::array_data * QGArray::newData()
 {
     return new array_data;
 }
 
 
 /*!
   Deletes the shared array block, \a p.
 */
 
 void QGArray::deleteData( array_data *p )
 {
     delete p;
     p = 0;
 }
diff --git a/qmake/tools/qgdict.cpp b/qmake/tools/qgdict.cpp
index c431ff8..3d49fc7 100644
--- a/qmake/tools/qgdict.cpp
+++ b/qmake/tools/qgdict.cpp
@@ -1,1146 +1,1149 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QGDict and QGDictIterator classes
 **
 ** Created : 920529
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qgdict.h"
 #include "qptrlist.h"
 #include "qstring.h"
 #include "qdatastream.h"
 #include <ctype.h>
 
 /*!
   \class QGDict
   \reentrant
   \ingroup collection
   \brief The QGDict class is an internal class for implementing QDict template classes.
 
   \internal
 
   QGDict is a strictly internal class that acts as a base class for the
   \link collection.html collection classes\endlink QDict and QIntDict.
 
   QGDict has some virtual functions that can be reimplemented to customize
   the subclasses.
   \list
   \i read() reads a collection/dictionary item from a QDataStream.
   \i write() writes a collection/dictionary item to a QDataStream.
   \endlist
   Normally, you do not have to reimplement any of these functions.
 */
 
 static const int op_find = 0;
 static const int op_insert = 1;
 static const int op_replace = 2;
 
 
 class QGDItList : public QPtrList<QGDictIterator>
 {
 public:
     QGDItList() : QPtrList<QGDictIterator>() {}
     QGDItList( const QGDItList &list ) : QPtrList<QGDictIterator>(list) {}
     ~QGDItList() { clear(); }
     QGDItList &operator=(const QGDItList &list)
 	{ return (QGDItList&)QPtrList<QGDictIterator>::operator=(list); }
 };
 
 
 /*****************************************************************************
   Default implementation of special and virtual functions
  *****************************************************************************/
 
 /*!
   Returns the hash key for \a key, when key is a string.
 */
 
 int QGDict::hashKeyString( const QString &key )
 {
 #if defined(QT_CHECK_NULL)
     if ( key.isNull() )
 	qWarning( "QGDict::hashKeyString: Invalid null key" );
 #endif
     int i;
     register uint h=0;
     uint g;
     const QChar *p = key.unicode();
     if ( cases ) {				// case sensitive
 	for ( i=0; i<(int)key.length(); i++ ) {
 	    h = (h<<4) + p[i].cell();
 	    if ( (g = h & 0xf0000000) )
 		h ^= g >> 24;
 	    h &= ~g;
 	}
     } else {					// case insensitive
 	for ( i=0; i<(int)key.length(); i++ ) {
 	    h = (h<<4) + p[i].lower().cell();
 	    if ( (g = h & 0xf0000000) )
 		h ^= g >> 24;
 	    h &= ~g;
 	}
     }
     int index = h;
     if ( index < 0 )				// adjust index to table size
 	index = -index;
     return index;
 }
 
 /*!
   Returns the hash key for \a key, which is a C string.
 */
 
 int QGDict::hashKeyAscii( const char *key )
 {
 #if defined(QT_CHECK_NULL)
     if ( key == 0 )
 	qWarning( "QGDict::hashAsciiKey: Invalid null key" );
 #endif
     register const char *k = key;
     register uint h=0;
     uint g;
     if ( cases ) {				// case sensitive
 	while ( *k ) {
 	    h = (h<<4) + *k++;
 	    if ( (g = h & 0xf0000000) )
 		h ^= g >> 24;
 	    h &= ~g;
 	}
     } else {					// case insensitive
 	while ( *k ) {
 	    h = (h<<4) + tolower((uchar) *k);
 	    if ( (g = h & 0xf0000000) )
 		h ^= g >> 24;
 	    h &= ~g;
 	    k++;
 	}
     }
     int index = h;
     if ( index < 0 )				// adjust index to table size
 	index = -index;
     return index;
 }
 
 #ifndef QT_NO_DATASTREAM
 
 /*!
     \overload
   Reads a collection/dictionary item from the stream \a s and returns a
   reference to the stream.
 
   The default implementation sets \a item to 0.
 
   \sa write()
 */
 
 QDataStream& QGDict::read( QDataStream &s, QPtrCollection::Item &item )
 {
     item = 0;
     return s;
 }
 
 /*!
     \overload
   Writes a collection/dictionary item to the stream \a s and returns a
   reference to the stream.
 
   \sa read()
 */
 
 QDataStream& QGDict::write( QDataStream &s, QPtrCollection::Item ) const
 {
     return s;
 }
 #endif //QT_NO_DATASTREAM
 
 /*****************************************************************************
   QGDict member functions
  *****************************************************************************/
 
 /*!
   Constructs a dictionary.
 
   \a len is the initial size of the dictionary.
   The key type is \a kt which may be \c StringKey, \c AsciiKey,
   \c IntKey or \c PtrKey. The case-sensitivity of lookups is set with
   \a caseSensitive. Keys are copied if \a copyKeys is TRUE.
 */
 
 QGDict::QGDict( uint len, KeyType kt, bool caseSensitive, bool copyKeys )
 {
     init( len, kt, caseSensitive, copyKeys );
 }
 
 
 void QGDict::init( uint len, KeyType kt, bool caseSensitive, bool copyKeys )
 {
-    vec = new QBaseBucket *[vlen = len];		// allocate hash table
+    vlen = len;
+    if ( vlen == 0 )
+	vlen = 17;
+    vec = new QBaseBucket *[vlen];
     Q_CHECK_PTR( vec );
     memset( (char*)vec, 0, vlen*sizeof(QBaseBucket*) );
     numItems  = 0;
     iterators = 0;
     // The caseSensitive and copyKey options don't make sense for
     // all dict types.
     switch ( (keytype = (uint)kt) ) {
 	case StringKey:
 	    cases = caseSensitive;
 	    copyk = FALSE;
 	    break;
 	case AsciiKey:
 	    cases = caseSensitive;
 	    copyk = copyKeys;
 	    break;
 	default:
 	    cases = FALSE;
 	    copyk = FALSE;
 	    break;
     }
 }
 
 
 /*!
   Constructs a copy of \a dict.
 */
 
 QGDict::QGDict( const QGDict & dict )
     : QPtrCollection( dict )
 {
     init( dict.vlen, (KeyType)dict.keytype, dict.cases, dict.copyk );
     QGDictIterator it( dict );
     while ( it.get() ) {			// copy from other dict
 	switch ( keytype ) {
 	    case StringKey:
 		look_string( it.getKeyString(), it.get(), op_insert );
 		break;
 	    case AsciiKey:
 		look_ascii( it.getKeyAscii(), it.get(), op_insert );
 		break;
 	    case IntKey:
 		look_int( it.getKeyInt(), it.get(), op_insert );
 		break;
 	    case PtrKey:
 		look_ptr( it.getKeyPtr(), it.get(), op_insert );
 		break;
 	}
 	++it;
     }
 }
 
 
 /*!
   Removes all items from the dictionary and destroys it.
 */
 
 QGDict::~QGDict()
 {
     clear();					// delete everything
     delete [] vec;
     if ( !iterators )				// no iterators for this dict
 	return;
     QGDictIterator *i = iterators->first();
     while ( i ) {				// notify all iterators that
 	i->dict = 0;				// this dict is deleted
 	i = iterators->next();
     }
     delete iterators;
 }
 
 
 /*!
   Assigns \a dict to this dictionary.
 */
 
 QGDict &QGDict::operator=( const QGDict &dict )
 {
     if ( &dict == this )
 	return *this;
     clear();
     QGDictIterator it( dict );
     while ( it.get() ) {			// copy from other dict
 	switch ( keytype ) {
 	    case StringKey:
 		look_string( it.getKeyString(), it.get(), op_insert );
 		break;
 	    case AsciiKey:
 		look_ascii( it.getKeyAscii(), it.get(), op_insert );
 		break;
 	    case IntKey:
 		look_int( it.getKeyInt(), it.get(), op_insert );
 		break;
 	    case PtrKey:
 		look_ptr( it.getKeyPtr(), it.get(), op_insert );
 		break;
 	}
 	++it;
     }
     return *this;
 }
 
 /*!
   \fn uint QGDict::count() const
 
   Returns the number of items in the dictionary.
 */
 
 /*!
   \fn uint QGDict::size() const
 
   Returns the size of the hash array.
 */
 
 /*!
   The do-it-all function; \a op is one of op_find, op_insert, op_replace.
   The key is \a key and the item is \a d.
 */
 
 QPtrCollection::Item QGDict::look_string( const QString &key, QPtrCollection::Item d,
 				       int op )
 {
     QStringBucket *n = 0;
     int	index = hashKeyString(key) % vlen;
     if ( op == op_find ) {			// find
 	if ( cases ) {
 	    n = (QStringBucket*)vec[index];
 	    while( n != 0 ) {
 		if ( key == n->getKey() )
 		    return n->getData();	// item found
 		n = (QStringBucket*)n->getNext();
 	    }
 	} else {
 	    QString k = key.lower();
 	    n = (QStringBucket*)vec[index];
 	    while( n != 0 ) {
 		if ( k == n->getKey().lower() )
 		    return n->getData();	// item found
 		n = (QStringBucket*)n->getNext();
 	    }
 	}
 	return 0;				// not found
     }
     if ( op == op_replace ) {			// replace
 	if ( vec[index] != 0 )			// maybe something there
 	    remove_string( key );
     }
     // op_insert or op_replace
     n = new QStringBucket(key,newItem(d),vec[index]);
     Q_CHECK_PTR( n );
 #if defined(QT_CHECK_NULL)
     if ( n->getData() == 0 )
 	qWarning( "QDict: Cannot insert null item" );
 #endif
     vec[index] = n;
     numItems++;
     return n->getData();
 }
 
 QPtrCollection::Item QGDict::look_ascii( const char *key, QPtrCollection::Item d, int op )
 {
     QAsciiBucket *n;
     int	index = hashKeyAscii(key) % vlen;
     if ( op == op_find ) {			// find
 	if ( cases ) {
 	    for ( n=(QAsciiBucket*)vec[index]; n;
 		  n=(QAsciiBucket*)n->getNext() ) {
 		if ( qstrcmp(n->getKey(),key) == 0 )
 		    return n->getData();	// item found
 	    }
 	} else {
 	    for ( n=(QAsciiBucket*)vec[index]; n;
 		  n=(QAsciiBucket*)n->getNext() ) {
 		if ( qstricmp(n->getKey(),key) == 0 )
 		    return n->getData();	// item found
 	    }
 	}
 	return 0;				// not found
     }
     if ( op == op_replace ) {			// replace
 	if ( vec[index] != 0 )			// maybe something there
 	    remove_ascii( key );
     }
     // op_insert or op_replace
     n = new QAsciiBucket(copyk ? qstrdup(key) : key,newItem(d),vec[index]);
     Q_CHECK_PTR( n );
 #if defined(QT_CHECK_NULL)
     if ( n->getData() == 0 )
 	qWarning( "QAsciiDict: Cannot insert null item" );
 #endif
     vec[index] = n;
     numItems++;
     return n->getData();
 }
 
 QPtrCollection::Item QGDict::look_int( long key, QPtrCollection::Item d, int op )
 {
     QIntBucket *n;
     int index = (int)((ulong)key % vlen);	// simple hash
     if ( op == op_find ) {			// find
 	for ( n=(QIntBucket*)vec[index]; n;
 	      n=(QIntBucket*)n->getNext() ) {
 	    if ( n->getKey() == key )
 		return n->getData();		// item found
 	}
 	return 0;				// not found
     }
     if ( op == op_replace ) {			// replace
 	if ( vec[index] != 0 )			// maybe something there
 	    remove_int( key );
     }
     // op_insert or op_replace
     n = new QIntBucket(key,newItem(d),vec[index]);
     Q_CHECK_PTR( n );
 #if defined(QT_CHECK_NULL)
     if ( n->getData() == 0 )
 	qWarning( "QIntDict: Cannot insert null item" );
 #endif
     vec[index] = n;
     numItems++;
     return n->getData();
 }
 
 QPtrCollection::Item QGDict::look_ptr( void *key, QPtrCollection::Item d, int op )
 {
     QPtrBucket *n;
     int index = (int)((ulong)key % vlen);	// simple hash
     if ( op == op_find ) {			// find
 	for ( n=(QPtrBucket*)vec[index]; n;
 	      n=(QPtrBucket*)n->getNext() ) {
 	    if ( n->getKey() == key )
 		return n->getData();		// item found
 	}
 	return 0;				// not found
     }
     if ( op == op_replace ) {			// replace
 	if ( vec[index] != 0 )			// maybe something there
 	    remove_ptr( key );
     }
     // op_insert or op_replace
     n = new QPtrBucket(key,newItem(d),vec[index]);
     Q_CHECK_PTR( n );
 #if defined(QT_CHECK_NULL)
     if ( n->getData() == 0 )
 	qWarning( "QPtrDict: Cannot insert null item" );
 #endif
     vec[index] = n;
     numItems++;
     return n->getData();
 }
 
 
 /*!
   Changes the size of the hashtable to \a newsize.
   The contents of the dictionary are preserved,
   but all iterators on the dictionary become invalid.
 */
 void QGDict::resize( uint newsize )
 {
     // Save old information
     QBaseBucket **old_vec = vec;
     uint old_vlen  = vlen;
     bool old_copyk = copyk;
 
     vec = new QBaseBucket *[vlen = newsize];
     Q_CHECK_PTR( vec );
     memset( (char*)vec, 0, vlen*sizeof(QBaseBucket*) );
     numItems = 0;
     copyk = FALSE;
 
     // Reinsert every item from vec, deleting vec as we go
     for ( uint index = 0; index < old_vlen; index++ ) {
 	switch ( keytype ) {
 	    case StringKey:
 		{
 		    QStringBucket *n=(QStringBucket *)old_vec[index];
 		    while ( n ) {
 			look_string( n->getKey(), n->getData(), op_insert );
 			QStringBucket *t=(QStringBucket *)n->getNext();
 			delete n;
 			n = t;
 		    }
 		}
 		break;
 	    case AsciiKey:
 		{
 		    QAsciiBucket *n=(QAsciiBucket *)old_vec[index];
 		    while ( n ) {
 			look_ascii( n->getKey(), n->getData(), op_insert );
 			QAsciiBucket *t=(QAsciiBucket *)n->getNext();
 			delete n;
 			n = t;
 		    }
 		}
 		break;
 	    case IntKey:
 		{
 		    QIntBucket *n=(QIntBucket *)old_vec[index];
 		    while ( n ) {
 			look_int( n->getKey(), n->getData(), op_insert );
 			QIntBucket *t=(QIntBucket *)n->getNext();
 			delete n;
 			n = t;
 		    }
 		}
 		break;
 	    case PtrKey:
 		{
 		    QPtrBucket *n=(QPtrBucket *)old_vec[index];
 		    while ( n ) {
 			look_ptr( n->getKey(), n->getData(), op_insert );
 			QPtrBucket *t=(QPtrBucket *)n->getNext();
 			delete n;
 			n = t;
 		    }
 		}
 		break;
 	}
     }
     delete [] old_vec;
 
     // Restore state
     copyk = old_copyk;
 
     // Invalidate all iterators, since order is lost
     if ( iterators && iterators->count() ) {
 	QGDictIterator *i = iterators->first();
 	while ( i ) {
 	    i->toFirst();
 	    i = iterators->next();
 	}
     }
 }
 
 /*!
   Unlinks the bucket with the specified key (and specified data pointer,
   if it is set).
 */
 
 void QGDict::unlink_common( int index, QBaseBucket *node, QBaseBucket *prev )
 {
     if ( iterators && iterators->count() ) {	// update iterators
 	QGDictIterator *i = iterators->first();
 	while ( i ) {				// invalidate all iterators
 	    if ( i->curNode == node )		// referring to pending node
 		i->operator++();
 	    i = iterators->next();
 	}
     }
     if ( prev )					// unlink node
 	prev->setNext( node->getNext() );
     else
 	vec[index] = node->getNext();
     numItems--;
 }
 
 QStringBucket *QGDict::unlink_string( const QString &key, QPtrCollection::Item d )
 {
     if ( numItems == 0 )			// nothing in dictionary
 	return 0;
     QStringBucket *n;
     QStringBucket *prev = 0;
     int index = hashKeyString(key) % vlen;
     if ( cases ) {
 	for ( n=(QStringBucket*)vec[index]; n;
 	      n=(QStringBucket*)n->getNext() ) {
 	    bool found = (key == n->getKey());
 	    if ( found && d )
 		found = (n->getData() == d);
 	    if ( found ) {
 		unlink_common(index,n,prev);
 		return n;
 	    }
 	    prev = n;
 	}
     } else {
 	QString k = key.lower();
 	for ( n=(QStringBucket*)vec[index]; n;
 	      n=(QStringBucket*)n->getNext() ) {
 	    bool found = (k == n->getKey().lower());
 	    if ( found && d )
 		found = (n->getData() == d);
 	    if ( found ) {
 		unlink_common(index,n,prev);
 		return n;
 	    }
 	    prev = n;
 	}
     }
     return 0;
 }
 
 QAsciiBucket *QGDict::unlink_ascii( const char *key, QPtrCollection::Item d )
 {
     if ( numItems == 0 )			// nothing in dictionary
 	return 0;
     QAsciiBucket *n;
     QAsciiBucket *prev = 0;
     int index = hashKeyAscii(key) % vlen;
     for ( n=(QAsciiBucket *)vec[index]; n; n=(QAsciiBucket *)n->getNext() ) {
 	bool found = (cases ? qstrcmp(n->getKey(),key)
 		       : qstricmp(n->getKey(),key)) == 0;
 	if ( found && d )
 	    found = (n->getData() == d);
 	if ( found ) {
 	    unlink_common(index,n,prev);
 	    return n;
 	}
 	prev = n;
     }
     return 0;
 }
 
 QIntBucket *QGDict::unlink_int( long key, QPtrCollection::Item d )
 {
     if ( numItems == 0 )			// nothing in dictionary
 	return 0;
     QIntBucket *n;
     QIntBucket *prev = 0;
     int index = (int)((ulong)key % vlen);
     for ( n=(QIntBucket *)vec[index]; n; n=(QIntBucket *)n->getNext() ) {
 	bool found = (n->getKey() == key);
 	if ( found && d )
 	    found = (n->getData() == d);
 	if ( found ) {
 	    unlink_common(index,n,prev);
 	    return n;
 	}
 	prev = n;
     }
     return 0;
 }
 
 QPtrBucket *QGDict::unlink_ptr( void *key, QPtrCollection::Item d )
 {
     if ( numItems == 0 )			// nothing in dictionary
 	return 0;
     QPtrBucket *n;
     QPtrBucket *prev = 0;
     int index = (int)((ulong)key % vlen);
     for ( n=(QPtrBucket *)vec[index]; n; n=(QPtrBucket *)n->getNext() ) {
 	bool found = (n->getKey() == key);
 	if ( found && d )
 	    found = (n->getData() == d);
 	if ( found ) {
 	    unlink_common(index,n,prev);
 	    return n;
 	}
 	prev = n;
     }
     return 0;
 }
 
 
 /*!
   Removes the item with the specified \a key.  If \a item is not null,
   the remove will match the \a item as well (used to remove an
   item when several items have the same key).
 */
 
 bool QGDict::remove_string( const QString &key, QPtrCollection::Item item )
 {
     QStringBucket *n = unlink_string( key, item );
     if ( n ) {
 	deleteItem( n->getData() );
 	delete n;
 	return TRUE;
     } else {
 	return FALSE;
     }
 }
 
 bool QGDict::remove_ascii( const char *key, QPtrCollection::Item item )
 {
     QAsciiBucket *n = unlink_ascii( key, item );
     if ( n ) {
 	if ( copyk )
 	    delete [] (char *)n->getKey();
 	deleteItem( n->getData() );
 	delete n;
     }
     return n != 0;
 }
 
 bool QGDict::remove_int( long key, QPtrCollection::Item item )
 {
     QIntBucket *n = unlink_int( key, item );
     if ( n ) {
 	deleteItem( n->getData() );
 	delete n;
     }
     return n != 0;
 }
 
 bool QGDict::remove_ptr( void *key, QPtrCollection::Item item )
 {
     QPtrBucket *n = unlink_ptr( key, item );
     if ( n ) {
 	deleteItem( n->getData() );
 	delete n;
     }
     return n != 0;
 }
 
 QPtrCollection::Item QGDict::take_string( const QString &key )
 {
     QStringBucket *n = unlink_string( key );
     Item d;
     if ( n ) {
 	d = n->getData();
 	delete n;
     } else {
 	d = 0;
     }
     return d;
 }
 
 QPtrCollection::Item QGDict::take_ascii( const char *key )
 {
     QAsciiBucket *n = unlink_ascii( key );
     Item d;
     if ( n ) {
 	if ( copyk )
 	    delete [] (char *)n->getKey();
 	d = n->getData();
 	delete n;
     } else {
 	d = 0;
     }
     return d;
 }
 
 QPtrCollection::Item QGDict::take_int( long key )
 {
     QIntBucket *n = unlink_int( key );
     Item d;
     if ( n ) {
 	d = n->getData();
 	delete n;
     } else {
 	d = 0;
     }
     return d;
 }
 
 QPtrCollection::Item QGDict::take_ptr( void *key )
 {
     QPtrBucket *n = unlink_ptr( key );
     Item d;
     if ( n ) {
 	d = n->getData();
 	delete n;
     } else {
 	d = 0;
     }
     return d;
 }
 
 /*!
   Removes all items from the dictionary.
 */
 void QGDict::clear()
 {
     if ( !numItems )
 	return;
     numItems = 0;				// disable remove() function
     for ( uint j=0; j<vlen; j++ ) {		// destroy hash table
 	if ( vec[j] ) {
 	    switch ( keytype ) {
 		case StringKey:
 		    {
 			QStringBucket *n=(QStringBucket *)vec[j];
 			while ( n ) {
 			    QStringBucket *next = (QStringBucket*)n->getNext();
 			    deleteItem( n->getData() );
 			    delete n;
 			    n = next;
 			}
 		    }
 		    break;
 		case AsciiKey:
 		    {
 			QAsciiBucket *n=(QAsciiBucket *)vec[j];
 			while ( n ) {
 			    QAsciiBucket *next = (QAsciiBucket*)n->getNext();
 			    if ( copyk )
 				delete [] (char *)n->getKey();
 			    deleteItem( n->getData() );
 			    delete n;
 			    n = next;
 			}
 		    }
 		    break;
 		case IntKey:
 		    {
 			QIntBucket *n=(QIntBucket *)vec[j];
 			while ( n ) {
 			    QIntBucket *next = (QIntBucket*)n->getNext();
 			    deleteItem( n->getData() );
 			    delete n;
 			    n = next;
 			}
 		    }
 		    break;
 		case PtrKey:
 		    {
 			QPtrBucket *n=(QPtrBucket *)vec[j];
 			while ( n ) {
 			    QPtrBucket *next = (QPtrBucket*)n->getNext();
 			    deleteItem( n->getData() );
 			    delete n;
 			    n = next;
 			}
 		    }
 		    break;
 	    }
 	    vec[j] = 0;				// detach list of buckets
 	}
     }
     if ( iterators && iterators->count() ) {	// invalidate all iterators
 	QGDictIterator *i = iterators->first();
 	while ( i ) {
 	    i->curNode = 0;
 	    i = iterators->next();
 	}
     }
 }
 
 /*!
   Outputs debug statistics.
 */
 void QGDict::statistics() const
 {
 #if defined(QT_DEBUG)
     QString line;
     line.fill( '-', 60 );
     double real, ideal;
     qDebug( line.ascii() );
     qDebug( "DICTIONARY STATISTICS:" );
     if ( count() == 0 ) {
 	qDebug( "Empty!" );
 	qDebug( line.ascii() );
 	return;
     }
     real = 0.0;
     ideal = (float)count()/(2.0*size())*(count()+2.0*size()-1);
     uint i = 0;
     while ( i<size() ) {
 	QBaseBucket *n = vec[i];
 	int b = 0;
 	while ( n ) {				// count number of buckets
 	    b++;
 	    n = n->getNext();
 	}
 	real = real + (double)b * ((double)b+1.0)/2.0;
 	char buf[80], *pbuf;
 	if ( b > 78 )
 	    b = 78;
 	pbuf = buf;
 	while ( b-- )
 	    *pbuf++ = '*';
 	*pbuf = '\0';
 	qDebug( buf );
 	i++;
     }
     qDebug( "Array size = %d", size() );
     qDebug( "# items    = %d", count() );
     qDebug( "Real dist  = %g", real );
     qDebug( "Rand dist  = %g", ideal );
     qDebug( "Real/Rand  = %g", real/ideal );
     qDebug( line.ascii() );
 #endif // QT_DEBUG
 }
 
 
 /*****************************************************************************
   QGDict stream functions
  *****************************************************************************/
 #ifndef QT_NO_DATASTREAM
 QDataStream &operator>>( QDataStream &s, QGDict &dict )
 {
     return dict.read( s );
 }
 
 QDataStream &operator<<( QDataStream &s, const QGDict &dict )
 {
     return dict.write( s );
 }
 
 #if defined(Q_CC_DEC) && defined(__alpha) && (__DECCXX_VER-0 >= 50190001)
 #pragma message disable narrowptr
 #endif
 
 /*!
   Reads a dictionary from the stream \a s.
 */
 
 QDataStream &QGDict::read( QDataStream &s )
 {
     uint num;
     s >> num;					// read number of items
     clear();					// clear dict
     while ( num-- ) {				// read all items
 	Item d;
 	switch ( keytype ) {
 	    case StringKey:
 		{
 		    QString k;
 		    s >> k;
 		    read( s, d );
 		    look_string( k, d, op_insert );
 		}
 		break;
 	    case AsciiKey:
 		{
 		    char *k;
 		    s >> k;
 		    read( s, d );
 		    look_ascii( k, d, op_insert );
 		    if ( copyk )
 			delete [] k;
 		}
 		break;
 	    case IntKey:
 		{
 		    Q_UINT32 k;
 		    s >> k;
 		    read( s, d );
 		    look_int( k, d, op_insert );
 		}
 		break;
 	    case PtrKey:
 		{
 		    Q_UINT32 k;
 		    s >> k;
 		    read( s, d );
 		    // ### cannot insert 0 - this renders the thing
 		    // useless since all pointers are written as 0,
 		    // but hey, serializing pointers?  can it be done
 		    // at all, ever?
 		    if ( k )
 			look_ptr( (void *)k, d, op_insert );
 		}
 		break;
 	}
     }
     return s;
 }
 
 /*!
   Writes the dictionary to the stream \a s.
 */
 
 QDataStream& QGDict::write( QDataStream &s ) const
 {
     s << count();				// write number of items
     uint i = 0;
     while ( i<size() ) {
 	QBaseBucket *n = vec[i];
 	while ( n ) {				// write all buckets
 	    switch ( keytype ) {
 		case StringKey:
 		    s << ((QStringBucket*)n)->getKey();
 		    break;
 		case AsciiKey:
 		    s << ((QAsciiBucket*)n)->getKey();
 		    break;
 		case IntKey:
 		    s << (Q_UINT32)((QIntBucket*)n)->getKey();
 		    break;
 		case PtrKey:
 		    s << (Q_UINT32)0; // ### cannot serialize a pointer
 		    break;
 	    }
 	    write( s, n->getData() );		// write data
 	    n = n->getNext();
 	}
 	i++;
     }
     return s;
 }
 #endif //QT_NO_DATASTREAM
 
 /*****************************************************************************
   QGDictIterator member functions
  *****************************************************************************/
 
 /*!
   \class QGDictIterator qgdict.h
   \reentrant
   \ingroup collection
   \brief The QGDictIterator class is an internal class for implementing QDictIterator and QIntDictIterator.
 
   \internal
 
   QGDictIterator is a strictly internal class that does the heavy work for
   QDictIterator and QIntDictIterator.
 */
 
 /*!
   Constructs an iterator that operates on the dictionary \a d.
 */
 
 QGDictIterator::QGDictIterator( const QGDict &d )
 {
     dict = (QGDict *)&d;			// get reference to dict
     toFirst();					// set to first noe
     if ( !dict->iterators ) {
 	dict->iterators = new QGDItList;	// create iterator list
 	Q_CHECK_PTR( dict->iterators );
     }
     dict->iterators->append( this );		// attach iterator to dict
 }
 
 /*!
   Constructs a copy of the iterator \a it.
 */
 
 QGDictIterator::QGDictIterator( const QGDictIterator &it )
 {
     dict = it.dict;
     curNode = it.curNode;
     curIndex = it.curIndex;
     if ( dict )
 	dict->iterators->append( this );	// attach iterator to dict
 }
 
 /*!
   Assigns a copy of the iterator \a it and returns a reference to this
   iterator.
 */
 
 QGDictIterator &QGDictIterator::operator=( const QGDictIterator &it )
 {
     if ( dict )					// detach from old dict
 	dict->iterators->removeRef( this );
     dict = it.dict;
     curNode = it.curNode;
     curIndex = it.curIndex;
     if ( dict )
 	dict->iterators->append( this );	// attach to new list
     return *this;
 }
 
 /*!
   Destroys the iterator.
 */
 
 QGDictIterator::~QGDictIterator()
 {
     if ( dict )					// detach iterator from dict
 	dict->iterators->removeRef( this );
 }
 
 
 /*!
   Sets the iterator to point to the first item in the dictionary.
 */
 
 QPtrCollection::Item QGDictIterator::toFirst()
 {
     if ( !dict ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QGDictIterator::toFirst: Dictionary has been deleted" );
 #endif
 	return 0;
     }
     if ( dict->count() == 0 ) {			// empty dictionary
 	curNode = 0;
 	return 0;
     }
     register uint i = 0;
     register QBaseBucket **v = dict->vec;
     while ( !(*v++) )
 	i++;
     curNode = dict->vec[i];
     curIndex = i;
     return curNode->getData();
 }
 
 
 /*!
   Moves to the next item (postfix).
 */
 
 QPtrCollection::Item QGDictIterator::operator()()
 {
     if ( !dict ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QGDictIterator::operator(): Dictionary has been deleted" );
 #endif
 	return 0;
     }
     if ( !curNode )
 	return 0;
     QPtrCollection::Item d = curNode->getData();
     this->operator++();
     return d;
 }
 
 /*!
   Moves to the next item (prefix).
 */
 
 QPtrCollection::Item QGDictIterator::operator++()
 {
     if ( !dict ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QGDictIterator::operator++: Dictionary has been deleted" );
 #endif
 	return 0;
     }
     if ( !curNode )
 	return 0;
     curNode = curNode->getNext();
     if ( !curNode ) {				// no next bucket
 	register uint i = curIndex + 1;		// look from next vec element
 	register QBaseBucket **v = &dict->vec[i];
 	while ( i < dict->size() && !(*v++) )
 	    i++;
 	if ( i == dict->size() ) {		// nothing found
 	    curNode = 0;
 	    return 0;
 	}
 	curNode = dict->vec[i];
 	curIndex = i;
     }
     return curNode->getData();
 }
 
 /*!
   Moves \a jumps positions forward.
 */
 
 QPtrCollection::Item QGDictIterator::operator+=( uint jumps )
 {
     while ( curNode && jumps-- )
 	operator++();
     return curNode ? curNode->getData() : 0;
 }
diff --git a/qmake/tools/qglist.cpp b/qmake/tools/qglist.cpp
index 155d585..bd27f8a 100644
--- a/qmake/tools/qglist.cpp
+++ b/qmake/tools/qglist.cpp
@@ -1,1255 +1,1251 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QGList and QGListIterator classes
 **
 ** Created : 920624
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qglist.h"
 #include "qgvector.h"
 #include "qdatastream.h"
 #include "qvaluelist.h"
 
 /*!
   \class QLNode qglist.h
   \reentrant
   \ingroup collection
   \brief The QLNode class is an internal class for the QPtrList template collection.
 
   \internal
 
   QLNode is a doubly-linked list node. It has three pointers:
   \list 1
   \i Pointer to the previous node.
   \i Pointer to the next node.
   \i Pointer to the actual data.
   \endlist
 
   It might sometimes be practical to have direct access to the list nodes
   in a QPtrList, but it is seldom required.
 
   Be very careful if you want to access the list nodes. The heap can
   easily get corrupted if you make a mistake.
 
   \sa QPtrList::currentNode(), QPtrList::removeNode(), QPtrList::takeNode()
 */
 
 /*!
   \fn QPtrCollection::Item QLNode::getData()
   Returns a pointer (\c void*) to the actual data in the list node.
 */
 
 
 /*!
   \class QGList qglist.h
   \reentrant
   \ingroup collection
   \brief The QGList class is an internal class for implementing Qt collection classes.
 
   \internal
 
   QGList is a strictly internal class that acts as a base class for
   several collection classes; QPtrList, QPtrQueue and QPtrStack.
 
   QGList has some virtual functions that can be reimplemented to
   customize the subclasses, namely compareItems(), read() and
   write. Normally, you do not have to reimplement any of these
   functions.  If you still want to reimplement them, see the QStrList
   class (qstrlist.h) for an example.
 */
 
 
 /* Internal helper class for QGList. Contains some optimization for
    the typically case where only one iterators is activre on the list.
  */
 class QGListIteratorList
 {
 public:
     QGListIteratorList()
 	: list(0), iterator(0) {
     }
     ~QGListIteratorList() {
 	notifyClear( TRUE );
 	delete list;
     }
 
     void add( QGListIterator* i ) {
 	if ( !iterator ) {
 	    iterator = i;
 	} else if ( list ) {
 	    list->push_front( i );
 	} else {
 	    list = new QValueList<QGListIterator*>;
 	    list->push_front( i );
 	}
     }
 
     void remove( QGListIterator* i ) {
 	if ( iterator == i ) {
 	    iterator = 0;
 	} else if ( list ) {
 	    list->remove( i );
 	    if ( list->isEmpty() ) {
 		delete list;
 		list = 0;
 	    }
 	}
     }
 
     void notifyClear( bool zeroList ) {
 	if ( iterator ) {
 	    if ( zeroList )
 		iterator->list = 0;
 	    iterator->curNode = 0;
 	}
 	if ( list ) {
 	    for ( QValueList<QGListIterator*>::Iterator i = list->begin(); i != list->end(); ++i ) {
 		if ( zeroList )
 		    (*i)->list = 0;
 		(*i)->curNode = 0;
 	    }
 	}
     }
 
     void notifyRemove( QLNode* n, QLNode* curNode ) {
 	if ( iterator ) {
 	    if ( iterator->curNode == n )
 		iterator->curNode = curNode;
 	}
 	if ( list ) {
 	    for ( QValueList<QGListIterator*>::Iterator i = list->begin(); i != list->end(); ++i ) {
 		if ( (*i)->curNode == n )
 		    (*i)->curNode = curNode;
 	    }
 	}
     }
 
 private:
     QValueList<QGListIterator*>* list;
     QGListIterator* iterator;
 };
 
 
 
 /*****************************************************************************
   Default implementation of virtual functions
  *****************************************************************************/
 
 /*!
   Documented as QPtrList::compareItems().
 
   Compares \a item1 with \a item2.
 */
 int QGList::compareItems( QPtrCollection::Item item1, QPtrCollection::Item item2 )
 {
     return item1 != item2;			// compare pointers
 }
 
 #ifndef QT_NO_DATASTREAM
 /*!
     \overload
   Reads a collection/list item from the stream \a s and returns a reference
   to the stream.
 
   The default implementation sets \a item to 0.
 
   \sa write()
 */
 
 QDataStream &QGList::read( QDataStream &s, QPtrCollection::Item &item )
 {
     item = 0;
     return s;
 }
 
 /*!
     \overload
   Writes a collection/list item to the stream \a s and
   returns a reference to the stream.
 
   The default implementation does nothing.
 
   \sa read()
 */
 
 QDataStream &QGList::write( QDataStream &s, QPtrCollection::Item ) const
 {
     return s;
 }
 #endif // QT_NO_DATASTREAM
 
 /*****************************************************************************
   QGList member functions
  *****************************************************************************/
 
 /*!
   Constructs an empty list.
 */
 
 QGList::QGList()
 {
     firstNode = lastNode = curNode = 0;		// initialize list
     numNodes  = 0;
     curIndex  = -1;
     iterators = 0;				// initialize iterator list
 }
 
 /*!
   Constructs a copy of \a list.
 */
 
 QGList::QGList( const QGList & list )
     : QPtrCollection( list )
 {
     firstNode = lastNode = curNode = 0;		// initialize list
     numNodes  = 0;
     curIndex  = -1;
     iterators = 0;				// initialize iterator list
     QLNode *n = list.firstNode;
     while ( n ) {				// copy all items from list
 	append( n->data );
 	n = n->next;
     }
 }
 
 /*!
   Removes all items from the list and destroys the list.
 */
 
 QGList::~QGList()
 {
     clear();
     delete iterators;
     // Workaround for GCC 2.7.* bug. Compiler constructs 'static' QGList
     // instances twice on the same address and therefore tries to destruct
     // twice on the same address! This is insane but let's try not to crash
     // here.
     iterators = 0;
 }
 
 
 /*!
   Assigns \a list to this list.
 */
 
 QGList& QGList::operator=( const QGList &list )
 {
     if ( &list == this )
 	return *this;
 
     clear();
     if ( list.count() > 0 ) {
 	QLNode *n = list.firstNode;
 	while ( n ) {				// copy all items from list
 	    append( n->data );
 	    n = n->next;
 	}
 	curNode	 = firstNode;
 	curIndex = 0;
     }
     return *this;
 }
 
 /*!
   Compares this list with \a list. Returns TRUE if the lists
   contain the same data, otherwise FALSE.
 */
 
 bool QGList::operator==( const QGList &list ) const
 {
     if ( count() != list.count() )
 	return FALSE;
 
     if ( count() == 0 )
 	return TRUE;
 
     QLNode *n1 = firstNode;
     QLNode *n2 = list.firstNode;
     while ( n1 && n2 ) {
 	// should be mutable
 	if ( ( (QGList*)this )->compareItems( n1->data, n2->data ) != 0 )
 	    return FALSE;
 	n1 = n1->next;
 	n2 = n2->next;
     }
 
     return TRUE;
 }
 
 /*!
   \fn uint QGList::count() const
 
   Returns the number of items in the list.
 */
 
 
 /*!
   Returns the node at position \a index.  Sets this node to current.
 */
 
 QLNode *QGList::locate( uint index )
 {
     if ( index == (uint)curIndex )		// current node ?
 	return curNode;
     if ( !curNode && firstNode ) {		// set current node
 	curNode	 = firstNode;
 	curIndex = 0;
     }
     register QLNode *node;
     int	 distance = index - curIndex;		// node distance to cur node
     bool forward;				// direction to traverse
 
-    if ( index >= numNodes ) {
-#if defined(QT_CHECK_RANGE)
-	qWarning( "QGList::locate: Index %d out of range", index );
-#endif
+    if ( index >= numNodes )
 	return 0;
-    }
 
     if ( distance < 0 )
 	distance = -distance;
     if ( (uint)distance < index && (uint)distance < numNodes - index ) {
 	node =	curNode;			// start from current node
 	forward = index > (uint)curIndex;
     } else if ( index < numNodes - index ) {	// start from first node
 	node = firstNode;
 	distance = index;
 	forward = TRUE;
     } else {					// start from last node
 	node = lastNode;
 	distance = numNodes - index - 1;
 	if ( distance < 0 )
 	    distance = 0;
 	forward = FALSE;
     }
     if ( forward ) {				// now run through nodes
 	while ( distance-- )
 	    node = node->next;
     } else {
 	while ( distance-- )
 	    node = node->prev;
     }
     curIndex = index;				// must update index
     return curNode = node;
 }
 
 
 /*!
   Inserts item \a d at its sorted position in the list.
 */
 
 void QGList::inSort( QPtrCollection::Item d )
 {
     int index = 0;
     register QLNode *n = firstNode;
     while ( n && compareItems(n->data,d) < 0 ){ // find position in list
 	n = n->next;
 	index++;
     }
     insertAt( index, d );
 }
 
 
 /*!
   Inserts item \a d at the start of the list.
 */
 
 void QGList::prepend( QPtrCollection::Item d )
 {
     register QLNode *n = new QLNode( newItem(d) );
     Q_CHECK_PTR( n );
     n->prev = 0;
     if ( (n->next = firstNode) )		// list is not empty
 	firstNode->prev = n;
     else					// initialize list
 	lastNode = n;
     firstNode = curNode = n;			// curNode affected
     numNodes++;
     curIndex = 0;
 }
 
 
 /*!
   Inserts item \a d at the end of the list.
 */
 
 void QGList::append( QPtrCollection::Item d )
 {
     register QLNode *n = new QLNode( newItem(d) );
     Q_CHECK_PTR( n );
     n->next = 0;
     if ( (n->prev = lastNode) )			// list is not empty
 	lastNode->next = n;
     else					// initialize list
 	firstNode = n;
     lastNode = curNode = n;			// curNode affected
     curIndex = numNodes;
     numNodes++;
 }
 
 
 /*!
   Inserts item \a d at position \a index in the list.
 */
 
 bool QGList::insertAt( uint index, QPtrCollection::Item d )
 {
     if ( index == 0 ) {
 	prepend( d );
 	return TRUE;
     } else if ( index == numNodes ) {
 	append( d );
 	return TRUE;
     }
     QLNode *nextNode = locate( index );
     if ( !nextNode )
 	return FALSE;
     QLNode *prevNode = nextNode->prev;
     register QLNode *n = new QLNode( newItem(d) );
     Q_CHECK_PTR( n );
     nextNode->prev = n;
     prevNode->next = n;
     n->prev = prevNode;				// link new node into list
     n->next = nextNode;
     curNode = n;				// curIndex set by locate()
     numNodes++;
     return TRUE;
 }
 
 
 /*!
   Relinks node \a n and makes it the first node in the list.
 */
 
 void QGList::relinkNode( QLNode *n )
 {
     if ( n == firstNode )			// already first
 	return;
     curNode = n;
     unlink();
     n->prev = 0;
     if ( (n->next = firstNode) )		// list is not empty
 	firstNode->prev = n;
     else					// initialize list
 	lastNode = n;
     firstNode = curNode = n;			// curNode affected
     numNodes++;
     curIndex = 0;
 }
 
 
 /*!
   Unlinks the current list node and returns a pointer to this node.
 */
 
 QLNode *QGList::unlink()
 {
     if ( curNode == 0 )				// null current node
 	return 0;
     register QLNode *n = curNode;		// unlink this node
     if ( n == firstNode ) {			// removing first node ?
 	if ( (firstNode = n->next) ) {
 	    firstNode->prev = 0;
 	} else {
 	    lastNode = curNode = 0;		// list becomes empty
 	    curIndex = -1;
 	}
     } else {
 	if ( n == lastNode ) {			// removing last node ?
 	    lastNode = n->prev;
 	    lastNode->next = 0;
 	} else {				// neither last nor first node
 	    n->prev->next = n->next;
 	    n->next->prev = n->prev;
 	}
     }
 
     if ( n->next ) {                            // change current node
         curNode = n->next;
     } else if ( n->prev ) {
         curNode = n->prev;
         curIndex--;
     }
 
     if ( iterators )
 	iterators->notifyRemove( n, curNode );
     numNodes--;
     return n;
 }
 
 
 /*!
   Removes the node \a n from the list.
 */
 
 bool QGList::removeNode( QLNode *n )
 {
 #if defined(QT_CHECK_NULL)
     if ( n == 0 || (n->prev && n->prev->next != n) ||
 	 (n->next && n->next->prev != n) ) {
 	qWarning( "QGList::removeNode: Corrupted node" );
 	return FALSE;
     }
 #endif
     curNode = n;
     unlink();					// unlink node
     deleteItem( n->data );			// deallocate this node
     delete n;
     curNode  = firstNode;
     curIndex = curNode ? 0 : -1;
     return TRUE;
 }
 
 /*!
   Removes the item \a d from the list.	Uses compareItems() to find the item.
 
   If \a d is 0, removes the current item.
 */
 
 bool QGList::remove( QPtrCollection::Item d )
 {
     if ( d && find(d) == -1 )
 	return FALSE;
     QLNode *n = unlink();
     if ( !n )
 	return FALSE;
     deleteItem( n->data );
     delete n;
     return TRUE;
 }
 
 /*!
   Removes the item \a d from the list.
 */
 
 bool QGList::removeRef( QPtrCollection::Item d )
 {
     if ( findRef(d) == -1 )
 	return FALSE;
     QLNode *n = unlink();
     if ( !n )
 	return FALSE;
     deleteItem( n->data );
     delete n;
     return TRUE;
 }
 
 /*!
   \fn bool QGList::removeFirst()
 
   Removes the first item in the list.
 */
 
 /*!
   \fn bool QGList::removeLast()
 
   Removes the last item in the list.
 */
 
 /*!
   Removes the item at position \a index from the list.
 */
 
 bool QGList::removeAt( uint index )
 {
     if ( !locate(index) )
 	return FALSE;
     QLNode *n = unlink();
     if ( !n )
 	return FALSE;
     deleteItem( n->data );
     delete n;
     return TRUE;
 }
 
 
 /*!
   Replaces the item at index \a index with \a d.
 */
 bool QGList::replaceAt( uint index, QPtrCollection::Item d )
 {
     QLNode *n = locate( index );
     if ( !n )
 	return FALSE;
     if ( n->data != d ) {
 	deleteItem( n->data );
 	n->data = newItem( d );
     }
     return TRUE;
 }
 
 
 
 /*!
   Takes the node \a n out of the list.
 */
 
 QPtrCollection::Item QGList::takeNode( QLNode *n )
 {
 #if defined(QT_CHECK_NULL)
     if ( n == 0 || (n->prev && n->prev->next != n) ||
 	 (n->next && n->next->prev != n) ) {
 	qWarning( "QGList::takeNode: Corrupted node" );
 	return 0;
     }
 #endif
     curNode = n;
     unlink();					// unlink node
     Item d = n->data;
     delete n;					// delete the node, not data
     curNode  = firstNode;
     curIndex = curNode ? 0 : -1;
     return d;
 }
 
 /*!
   Takes the current item out of the list.
 */
 
 QPtrCollection::Item QGList::take()
 {
     QLNode *n = unlink();			// unlink node
     Item d = n ? n->data : 0;
     delete n;					// delete node, keep contents
     return d;
 }
 
 /*!
   Takes the item at position \a index out of the list.
 */
 
 QPtrCollection::Item QGList::takeAt( uint index )
 {
     if ( !locate(index) )
 	return 0;
     QLNode *n = unlink();			// unlink node
     Item d = n ? n->data : 0;
     delete n;					// delete node, keep contents
     return d;
 }
 
 /*!
   Takes the first item out of the list.
 */
 
 QPtrCollection::Item QGList::takeFirst()
 {
     first();
     QLNode *n = unlink();			// unlink node
     Item d = n ? n->data : 0;
     delete n;
     return d;
 }
 
 /*!
   Takes the last item out of the list.
 */
 
 QPtrCollection::Item QGList::takeLast()
 {
     last();
     QLNode *n = unlink();			// unlink node
     Item d = n ? n->data : 0;
     delete n;
     return d;
 }
 
 
 /*!
   Removes all items from the list.
 */
 
 void QGList::clear()
 {
     register QLNode *n = firstNode;
 
     firstNode = lastNode = curNode = 0;		// initialize list
     numNodes = 0;
     curIndex = -1;
 
     if ( iterators )
 	iterators->notifyClear( FALSE );
 
     QLNode *prevNode;
     while ( n ) {				// for all nodes ...
 	deleteItem( n->data );			// deallocate data
 	prevNode = n;
 	n = n->next;
 	delete prevNode;			// deallocate node
     }
 }
 
 
 /*!
   Finds item \a d in the list. If \a fromStart is TRUE the search
   begins at the first node; otherwise it begins at the current node.
 */
 
 int QGList::findRef( QPtrCollection::Item d, bool fromStart )
 {
     register QLNode *n;
     int	     index;
     if ( fromStart ) {				// start from first node
 	n = firstNode;
 	index = 0;
     } else {					// start from current node
 	n = curNode;
 	index = curIndex;
     }
     while ( n && n->data != d ) {		// find exact match
 	n = n->next;
 	index++;
     }
     curNode = n;
     curIndex = n ? index : -1;
     return curIndex;				// return position of item
 }
 
 /*!
   Finds item \a d in the list using compareItems(). If \a fromStart is
   TRUE the search begins at the first node; otherwise it begins at the
   current node.
 */
 
 int QGList::find( QPtrCollection::Item d, bool fromStart )
 {
     register QLNode *n;
     int	     index;
     if ( fromStart ) {				// start from first node
 	n = firstNode;
 	index = 0;
     } else {					// start from current node
 	n = curNode;
 	index = curIndex;
     }
     while ( n && compareItems(n->data,d) ){	// find equal match
 	n = n->next;
 	index++;
     }
     curNode = n;
     curIndex = n ? index : -1;
     return curIndex;				// return position of item
 }
 
 
 /*!
   Counts the number item \a d occurs in the list.
 */
 
 uint QGList::containsRef( QPtrCollection::Item d ) const
 {
     register QLNode *n = firstNode;
     uint     count = 0;
     while ( n ) {				// for all nodes...
 	if ( n->data == d )			// count # exact matches
 	    count++;
 	n = n->next;
     }
     return count;
 }
 
 /*!
   Counts the number of times item \a d occurs in the list. Uses
   compareItems().
 */
 
 uint QGList::contains( QPtrCollection::Item d ) const
 {
     register QLNode *n = firstNode;
     uint     count = 0;
     QGList  *that = (QGList*)this;		// mutable for compareItems()
     while ( n ) {				// for all nodes...
 	if ( !that->compareItems(n->data,d) )	// count # equal matches
 	    count++;
 	n = n->next;
     }
     return count;
 }
 
 
 /*!
   \overload QPtrCollection::Item QGList::at( uint index )
 
   Sets the item at position \a index to the current item.
 */
 
 /*!
   \fn int QGList::at() const
 
   Returns the current index.
 */
 
 /*!
   \fn QLNode *QGList::currentNode() const
 
   Returns the current node.
 */
 
 /*!
   \fn QPtrCollection::Item QGList::get() const
 
   Returns the current item.
 */
 
 /*!
   \fn QPtrCollection::Item QGList::cfirst() const
 
   Returns the first item in the list.
 */
 
 /*!
   \fn QPtrCollection::Item QGList::clast() const
 
   Returns the last item in the list.
 */
 
 
 /*!
   Returns the first list item.	Sets this to current.
 */
 
 QPtrCollection::Item QGList::first()
 {
     if ( firstNode ) {
 	curIndex = 0;
 	return (curNode=firstNode)->data;
     }
     return 0;
 }
 
 /*!
   Returns the last list item.  Sets this to current.
 */
 
 QPtrCollection::Item QGList::last()
 {
     if ( lastNode ) {
 	curIndex = numNodes-1;
 	return (curNode=lastNode)->data;
     }
     return 0;
 }
 
 /*!
   Returns the next list item (after current).  Sets this to current.
 */
 
 QPtrCollection::Item QGList::next()
 {
     if ( curNode ) {
 	if ( curNode->next ) {
 	    curIndex++;
 	    curNode = curNode->next;
 	    return curNode->data;
 	}
 	curIndex = -1;
 	curNode = 0;
     }
     return 0;
 }
 
 /*!
   Returns the previous list item (before current).  Sets this to current.
 */
 
 QPtrCollection::Item QGList::prev()
 {
     if ( curNode ) {
 	if ( curNode->prev ) {
 	    curIndex--;
 	    curNode = curNode->prev;
 	    return curNode->data;
 	}
 	curIndex = -1;
 	curNode = 0;
     }
     return 0;
 }
 
 
 /*!
   Converts the list to a vector, \a vector.
 */
 
 void QGList::toVector( QGVector *vector ) const
 {
     vector->clear();
     if ( !vector->resize( count() ) )
 	return;
     register QLNode *n = firstNode;
     uint i = 0;
     while ( n ) {
 	vector->insert( i, n->data );
 	n = n->next;
 	i++;
     }
 }
 
 void QGList::heapSortPushDown( QPtrCollection::Item* heap, int first, int last )
 {
     int r = first;
     while( r <= last/2 ) {
 	// Node r has only one child ?
 	if ( last == 2*r ) {
 	    // Need for swapping ?
 	    if ( compareItems( heap[r], heap[ 2*r ] ) > 0 ) {
 		QPtrCollection::Item tmp = heap[r];
 		heap[ r ] = heap[ 2*r ];
 		heap[ 2*r ] = tmp;
 	    }
 	    // That's it ...
 	    r = last;
 	} else {
 	    // Node has two children
 	    if ( compareItems( heap[r], heap[ 2*r ] ) > 0 &&
 		 compareItems( heap[ 2*r ], heap[ 2*r+1 ] ) <= 0 ) {
 		// Swap with left child
 		QPtrCollection::Item tmp = heap[r];
 		heap[ r ] = heap[ 2*r ];
 		heap[ 2*r ] = tmp;
 		r *= 2;
 	    } else if ( compareItems( heap[r], heap[ 2*r+1 ] ) > 0 &&
 			compareItems( heap[ 2*r+1 ], heap[ 2*r ] ) < 0 ) {
 		// Swap with right child
 		QPtrCollection::Item tmp = heap[r];
 		heap[ r ] = heap[ 2*r+1 ];
 		heap[ 2*r+1 ] = tmp;
 		r = 2*r+1;
 	    } else {
 		// We are done
 		r = last;
 	    }
 	}
     }
 }
 
 
 /*! Sorts the list by the result of the virtual compareItems() function.
 
   The Heap-Sort algorithm is used for sorting.  It sorts n items with
   O(n*log n) compares.  This is the asymptotic optimal solution of the
   sorting problem.
 */
 
 void QGList::sort()
 {
     uint n = count();
     if ( n < 2 )
 	return;
 
     // Create the heap
     QPtrCollection::Item* realheap = new QPtrCollection::Item[ n ];
     // Wow, what a fake. But I want the heap to be indexed as 1...n
     QPtrCollection::Item* heap = realheap - 1;
     int size = 0;
     QLNode* insert = firstNode;
     for( ; insert != 0; insert = insert->next ) {
 	heap[++size] = insert->data;
 	int i = size;
 	while( i > 1 && compareItems( heap[i], heap[ i / 2 ] ) < 0 ) {
 	    QPtrCollection::Item tmp = heap[ i ];
 	    heap[ i ] = heap[ i/2 ];
 	    heap[ i/2 ] = tmp;
 	    i /= 2;
 	}
     }
 
     insert = firstNode;
     // Now do the sorting
     for ( int i = n; i > 0; i-- ) {
 	insert->data = heap[1];
 	insert = insert->next;
 	if ( i > 1 ) {
 	    heap[1] = heap[i];
 	    heapSortPushDown( heap, 1, i - 1 );
 	}
     }
 
     delete [] realheap;
 }
 
 
 /*****************************************************************************
   QGList stream functions
  *****************************************************************************/
 
 #ifndef QT_NO_DATASTREAM
 QDataStream &operator>>( QDataStream &s, QGList &list )
 {						// read list
     return list.read( s );
 }
 
 QDataStream &operator<<( QDataStream &s, const QGList &list )
 {						// write list
     return list.write( s );
 }
 
 /*!
   Reads a list from the stream \a s.
 */
 
 QDataStream &QGList::read( QDataStream &s )
 {
     uint num;
     s >> num;					// read number of items
     clear();					// clear list
     while ( num-- ) {				// read all items
 	Item d;
 	read( s, d );
 	Q_CHECK_PTR( d );
 	if ( !d )				// no memory
 	    break;
 	QLNode *n = new QLNode( d );
 	Q_CHECK_PTR( n );
 	if ( !n )				// no memory
 	    break;
 	n->next = 0;
 	if ( (n->prev = lastNode) )		// list is not empty
 	    lastNode->next = n;
 	else					// initialize list
 	    firstNode = n;
 	lastNode = n;
 	numNodes++;
     }
     curNode  = firstNode;
     curIndex = curNode ? 0 : -1;
     return s;
 }
 
 /*!
   Writes the list to the stream \a s.
 */
 
 QDataStream &QGList::write( QDataStream &s ) const
 {
     s << count();				// write number of items
     QLNode *n = firstNode;
     while ( n ) {				// write all items
 	write( s, n->data );
 	n = n->next;
     }
     return s;
 }
 
 #endif // QT_NO_DATASTREAM
 
 /*****************************************************************************
   QGListIterator member functions
  *****************************************************************************/
 
 /*!
   \class QGListIterator qglist.h
   \reentrant
   \ingroup collection
   \brief The QGListIterator class is an internal class for implementing QPtrListIterator.
 
   \internal
 
   QGListIterator is a strictly internal class that does the heavy work for
   QPtrListIterator.
 */
 
 /*!
   \internal
   Constructs an iterator that operates on the list \a l.
 */
 
 QGListIterator::QGListIterator( const QGList &l )
 {
     list = (QGList *)&l;			// get reference to list
     curNode = list->firstNode;			// set to first node
     if ( !list->iterators ) {
 	list->iterators = new QGListIteratorList;		// create iterator list
 	Q_CHECK_PTR( list->iterators );
     }
     list->iterators->add( this );		// attach iterator to list
 }
 
 /*!
   \internal
   Constructs a copy of the iterator \a it.
 */
 
 QGListIterator::QGListIterator( const QGListIterator &it )
 {
     list = it.list;
     curNode = it.curNode;
     if ( list )
 	list->iterators->add( this );	// attach iterator to list
 }
 
 /*!
   \internal
   Assigns a copy of the iterator \a it and returns a reference to this
   iterator.
 */
 
 QGListIterator &QGListIterator::operator=( const QGListIterator &it )
 {
     if ( list )					// detach from old list
 	list->iterators->remove( this );
     list = it.list;
     curNode = it.curNode;
     if ( list )
 	list->iterators->add( this );	// attach to new list
     return *this;
 }
 
 /*!
   \internal
   Destroys the iterator.
 */
 
 QGListIterator::~QGListIterator()
 {
     if ( list )					// detach iterator from list
 	list->iterators->remove(this);
 }
 
 
 /*!
   \fn bool QGListIterator::atFirst() const
   \internal
   Returns TRUE if the iterator points to the first item, otherwise FALSE.
 */
 
 /*!
   \fn bool QGListIterator::atLast() const
   \internal
   Returns TRUE if the iterator points to the last item, otherwise FALSE.
 */
 
 
 /*!
   \internal
   Sets the list iterator to point to the first item in the list.
 */
 
 QPtrCollection::Item QGListIterator::toFirst()
 {
     if ( !list ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QGListIterator::toFirst: List has been deleted" );
 #endif
 	return 0;
     }
     return list->firstNode ? (curNode = list->firstNode)->getData() : 0;
 }
 
 /*!
   \internal
   Sets the list iterator to point to the last item in the list.
 */
 
 QPtrCollection::Item QGListIterator::toLast()
 {
     if ( !list ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QGListIterator::toLast: List has been deleted" );
 #endif
 	return 0;
     }
     return list->lastNode ? (curNode = list->lastNode)->getData() : 0;
 }
 
 
 /*!
   \fn QPtrCollection::Item QGListIterator::get() const
   \internal
   Returns the iterator item.
 */
 
 
 /*!
   \internal
   Moves to the next item (postfix).
 */
 
 QPtrCollection::Item QGListIterator::operator()()
 {
     if ( !curNode )
 	return 0;
     QPtrCollection::Item d = curNode->getData();
     curNode = curNode->next;
     return  d;
 }
 
 /*!
   \internal
   Moves to the next item (prefix).
 */
 
 QPtrCollection::Item QGListIterator::operator++()
 {
     if ( !curNode )
 	return 0;
     curNode = curNode->next;
     return curNode ? curNode->getData() : 0;
 }
 
 /*!
   \internal
   Moves \a jumps positions forward.
 */
 
 QPtrCollection::Item QGListIterator::operator+=( uint jumps )
 {
     while ( curNode && jumps-- )
 	curNode = curNode->next;
     return curNode ? curNode->getData() : 0;
 }
 
 /*!
   \internal
   Moves to the previous item (prefix).
 */
 
 QPtrCollection::Item QGListIterator::operator--()
 {
     if ( !curNode )
 	return 0;
     curNode = curNode->prev;
     return curNode ? curNode->getData() : 0;
 }
 
 /*!
   \internal
   Moves \a jumps positions backward.
 */
 
 QPtrCollection::Item QGListIterator::operator-=( uint jumps )
 {
     while ( curNode && jumps-- )
 	curNode = curNode->prev;
     return curNode ? curNode->getData() : 0;
 }
diff --git a/qmake/tools/qglobal.cpp b/qmake/tools/qglobal.cpp
index 47cd6bd..342005d 100644
--- a/qmake/tools/qglobal.cpp
+++ b/qmake/tools/qglobal.cpp
@@ -1,835 +1,868 @@
 /****************************************************************************
 ** $Id$
 **
 ** Global functions
 **
 ** Created : 920604
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qplatformdefs.h"
 
 #include "qasciidict.h"
 #include <limits.h>
 #include <stdio.h>
 #include <limits.h>
 #include <stdarg.h>
 #include <stdlib.h>
 
 
 /*!
     \relates QApplication
 
     Returns the Qt version number as a string, for example, "2.3.0" or
     "3.0.5".
 
     The \c QT_VERSION define has the numeric value in the form:
     0xmmiibb (m = major, i = minor, b = bugfix). For example, Qt
     3.0.5's \c QT_VERSION is 0x030005.
 */
 
 const char *qVersion()
 {
     return QT_VERSION_STR;
 }
 
 
 /*****************************************************************************
   System detection routines
  *****************************************************************************/
 
 static bool si_alreadyDone = FALSE;
 static int  si_wordSize;
 static bool si_bigEndian;
 
 /*!
     \relates QApplication
 
     Obtains information about the system.
 
     The system's word size in bits (typically 32) is returned in \a
     *wordSize. The \a *bigEndian is set to TRUE if this is a big-endian
     machine, or to FALSE if this is a little-endian machine.
 
     In debug mode, this function calls qFatal() with a message if the
     computer is truly weird (i.e. different endianness for 16 bit and
     32 bit integers); in release mode it returns FALSE.
 */
 
 bool qSysInfo( int *wordSize, bool *bigEndian )
 {
 #if defined(QT_CHECK_NULL)
     Q_ASSERT( wordSize != 0 );
     Q_ASSERT( bigEndian != 0 );
 #endif
 
     if ( si_alreadyDone ) {			// run it only once
 	*wordSize  = si_wordSize;
 	*bigEndian = si_bigEndian;
 	return TRUE;
     }
 
     si_wordSize = 0;
     Q_ULONG n = (Q_ULONG)(~0);
     while ( n ) {				// detect word size
 	si_wordSize++;
 	n /= 2;
     }
     *wordSize = si_wordSize;
 
     if ( *wordSize != 64 &&
 	 *wordSize != 32 &&
 	 *wordSize != 16 ) {			// word size: 16, 32 or 64
 #if defined(QT_CHECK_RANGE)
 	qFatal( "qSysInfo: Unsupported system word size %d", *wordSize );
 #endif
 	return FALSE;
     }
     if ( sizeof(Q_INT8) != 1 || sizeof(Q_INT16) != 2 || sizeof(Q_INT32) != 4 ||
 	 sizeof(Q_ULONG)*8 != si_wordSize || sizeof(float) != 4 || sizeof(double) != 8 ) {
 #if defined(QT_CHECK_RANGE)
 	qFatal( "qSysInfo: Unsupported system data type size" );
 #endif
 	return FALSE;
     }
 
     bool  be16, be32;				// determine byte ordering
     short ns = 0x1234;
     int	  nl = 0x12345678;
 
     unsigned char *p = (unsigned char *)(&ns);	// 16-bit integer
     be16 = *p == 0x12;
 
     p = (unsigned char *)(&nl);			// 32-bit integer
     if ( p[0] == 0x12 && p[1] == 0x34 && p[2] == 0x56 && p[3] == 0x78 )
 	be32 = TRUE;
     else
     if ( p[0] == 0x78 && p[1] == 0x56 && p[2] == 0x34 && p[3] == 0x12 )
 	be32 = FALSE;
     else
 	be32 = !be16;
 
     if ( be16 != be32 ) {			// strange machine!
 #if defined(QT_CHECK_RANGE)
 	qFatal( "qSysInfo: Inconsistent system byte order" );
 #endif
 	return FALSE;
     }
 
     *bigEndian = si_bigEndian = be32;
     si_alreadyDone = TRUE;
     return TRUE;
 }
 
-#if defined(Q_OS_WIN32) || defined(Q_OS_CYGWIN)
+#if !defined(QWS) && defined(Q_OS_MAC)
+
+#include "qt_mac.h"
+
+int qMacVersion()
+{
+    static int macver = Qt::MV_Unknown;
+    static bool first = TRUE;
+    if(first) {
+	first = FALSE;
+	long gestalt_version;
+	if(Gestalt(gestaltSystemVersion, &gestalt_version) == noErr) {
+	    if(gestalt_version >= 0x1020 && gestalt_version < 0x1030)
+		macver = Qt::MV_10_DOT_2;
+	    else if(gestalt_version >= 0x1010 && gestalt_version < 0x1020)
+		macver = Qt::MV_10_DOT_1;
+	}
+    }
+    return macver;
+}
+Qt::MacintoshVersion qt_macver = (Qt::MacintoshVersion)qMacVersion();
+#elif defined(Q_OS_WIN32) || defined(Q_OS_CYGWIN)
 bool qt_winunicode;
 
 #include "qt_windows.h"
 
 int qWinVersion()
 {
 #ifndef VER_PLATFORM_WIN32s
 #define VER_PLATFORM_WIN32s	    0
 #endif
 #ifndef VER_PLATFORM_WIN32_WINDOWS
 #define VER_PLATFORM_WIN32_WINDOWS  1
 #endif
 #ifndef VER_PLATFORM_WIN32_NT
 #define VER_PLATFORM_WIN32_NT	    2
 #endif
 
     static int winver = Qt::WV_NT;
     static int t=0;
     if ( !t ) {
 	t=1;
 #ifdef Q_OS_TEMP
 	OSVERSIONINFOW osver;
 	osver.dwOSVersionInfoSize = sizeof(osver);
 	GetVersionEx( &osver );
 #else
 	OSVERSIONINFOA osver;
 	osver.dwOSVersionInfoSize = sizeof(osver);
 	GetVersionExA( &osver );
 #endif
 	switch ( osver.dwPlatformId ) {
 	case VER_PLATFORM_WIN32s:
 	    winver = Qt::WV_32s;
 	    break;
 	case VER_PLATFORM_WIN32_WINDOWS:
 	    // We treat Windows Me (minor 90) the same as Windows 98
 	    if ( ( osver.dwMinorVersion == 10 ) || ( osver.dwMinorVersion == 90 ) )
 		winver = Qt::WV_98;
 	    else
 		winver = Qt::WV_95;
 	    break;
 	default: // VER_PLATFORM_WIN32_NT
 	    if ( osver.dwMajorVersion < 5 ) {
 		winver = Qt::WV_NT;
 	    } else if ( osver.dwMinorVersion == 0 ) {
 		winver = Qt::WV_2000;
 	    } else {
 		winver = Qt::WV_XP;
 	    }
 	}
     }
 
 #if defined(UNICODE)
     if ( winver & Qt::WV_NT_based )
 	qt_winunicode = TRUE;
     else
 #endif
 	qt_winunicode = FALSE;
 
     return winver;
 }
 
 Qt::WindowsVersion qt_winver = (Qt::WindowsVersion)qWinVersion();
 #endif
 
 
 /*****************************************************************************
   Debug output routines
  *****************************************************************************/
 
 /*!
     \fn void qDebug( const char *msg, ... )
 
     \relates QApplication
 
     Prints a debug message \a msg, or calls the message handler (if it
     has been installed).
 
     This function takes a format string and a list of arguments,
     similar to the C printf() function.
 
     Example:
     \code
 	qDebug( "my window handle = %x", myWidget->id() );
     \endcode
 
     Under X11, the text is printed to stderr. Under Windows, the text
     is sent to the debugger.
 
     \warning The internal buffer is limited to 8196 bytes (including
     the '\0'-terminator).
 
     \warning Passing (const char *)0 as argument to qDebug might lead
     to crashes on certain platforms due to the platforms printf implementation.
 
     \sa qWarning(), qFatal(), qInstallMsgHandler(),
 	\link debug.html Debugging\endlink
 */
 
 /*!
     \fn void qWarning( const char *msg, ... )
 
     \relates QApplication
 
     Prints a warning message \a msg, or calls the message handler (if
     it has been installed).
 
     This function takes a format string and a list of arguments,
     similar to the C printf() function.
 
     Example:
     \code
 	void f( int c )
 	{
 	    if ( c > 200 )
 		qWarning( "f: bad argument, c == %d", c );
 	}
     \endcode
 
     Under X11, the text is printed to stderr. Under Windows, the text
     is sent to the debugger.
 
     \warning The internal buffer is limited to 8196 bytes (including
     the '\0'-terminator).
 
     \warning Passing (const char *)0 as argument to qWarning might lead
     to crashes on certain platforms due to the platforms printf implementation.
 
     \sa qDebug(), qFatal(), qInstallMsgHandler(),
     \link debug.html Debugging\endlink
 */
 
 /*!
     \fn void qFatal( const char *msg, ... )
 
     \relates QApplication
 
     Prints a fatal error message \a msg and exits, or calls the
     message handler (if it has been installed).
 
     This function takes a format string and a list of arguments,
     similar to the C printf() function.
 
     Example:
     \code
 	int divide( int a, int b )
 	{
 	    if ( b == 0 )				// program error
 		qFatal( "divide: cannot divide by zero" );
 	    return a/b;
 	}
     \endcode
 
     Under X11, the text is printed to stderr. Under Windows, the text
     is sent to the debugger.
 
     \warning The internal buffer is limited to 8196 bytes (including
     the '\0'-terminator).
 
     \warning Passing (const char *)0 as argument to qFatal might lead
     to crashes on certain platforms due to the platforms printf implementation.
 
     \sa qDebug(), qWarning(), qInstallMsgHandler(),
     \link debug.html Debugging\endlink
 */
 
 
 static QtMsgHandler handler = 0;		// pointer to debug handler
 static const int QT_BUFFER_LENGTH = 8196;	// internal buffer length
 
 
 #ifdef Q_OS_MAC
-const unsigned char * p_str(const char * c, int len=-1)
+QString cfstring2qstring(CFStringRef str)
+{
+    CFIndex length = CFStringGetLength(str); 
+    if(const UniChar *chars = CFStringGetCharactersPtr(str)) 
+	return QString((QChar *)chars, length);
+    UniChar *buffer = (UniChar*)malloc(length * sizeof(UniChar)); 
+    CFStringGetCharacters(str, CFRangeMake(0, length), buffer); 
+    QString ret((QChar *)buffer, length);
+    free(buffer); 
+    return ret;
+}
+
+unsigned char * p_str(const char * c, int len=-1)
 {
     const int maxlen = 255;
     if(len == -1)
 	len = qstrlen(c);
     if(len > maxlen) {
 	qWarning( "p_str len must never exceed %d", maxlen );
 	len = maxlen;
     }
     unsigned char *ret = (unsigned char*)malloc(len+2);
     *ret=len;
     memcpy(((char *)ret)+1,c,len);
     *(ret+len+1) = '\0';
     return ret;
 }
 
-const unsigned char * p_str(const QString &s)
+unsigned char * p_str(const QString &s)
 {
     return p_str(s, s.length());
 }
 
 QCString p2qstring(const unsigned char *c) {
        char *arr = (char *)malloc(c[0] + 1);
        memcpy(arr, c+1, c[0]);
        arr[c[0]] = '\0';
        QCString ret = arr;
        delete arr;
        return ret;
 }
 #endif
 
 
 #ifdef Q_CC_MWERKS
 
 #include "qt_mac.h"
 
 extern bool qt_is_gui_used;
 static void mac_default_handler( const char *msg )
 {
     if ( qt_is_gui_used ) {
 	const char *p = p_str(msg);
 	DebugStr(p);
 	free(p);
     } else {
 	fprintf( stderr, msg );
     }
 }
 
 #endif
 
 
 void qDebug( const char *msg, ... )
 {
     char buf[QT_BUFFER_LENGTH];
     va_list ap;
     va_start( ap, msg );			// use variable arg list
     if ( handler ) {
 #if defined(QT_VSNPRINTF)
 	QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
 #else
 	vsprintf( buf, msg, ap );
 #endif
 	va_end( ap );
 	(*handler)( QtDebugMsg, buf );
     } else {
 #if defined(Q_CC_MWERKS)
 	vsprintf( buf, msg, ap );		// ### is there no vsnprintf()?
 	va_end( ap );
         mac_default_handler(buf);
 #else
 	vfprintf( stderr, msg, ap );
 	va_end( ap );
 	fprintf( stderr, "\n" );		// add newline
 #endif
     }
 }
 
 // copied... this looks really bad.
 void debug( const char *msg, ... )
 {
     char buf[QT_BUFFER_LENGTH];
     va_list ap;
     va_start( ap, msg );			// use variable arg list
     if ( handler ) {
 #if defined(QT_VSNPRINTF)
 	QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
 #else
 	vsprintf( buf, msg, ap );
 #endif
 	va_end( ap );
 	(*handler)( QtDebugMsg, buf );
     } else {
 #ifdef Q_CC_MWERKS
 	vsprintf( buf, msg, ap );		// ### is there no vsnprintf()?
 	va_end( ap );
         mac_default_handler(buf);
 #else
 	vfprintf( stderr, msg, ap );
 	va_end( ap );
 	fprintf( stderr, "\n" );		// add newline
 #endif
     }
 }
 
 void qWarning( const char *msg, ... )
 {
     char buf[QT_BUFFER_LENGTH];
     va_list ap;
     va_start( ap, msg );			// use variable arg list
     if ( handler ) {
 #if defined(QT_VSNPRINTF)
 	QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
 #else
 	vsprintf( buf, msg, ap );
 #endif
 	va_end( ap );
 	(*handler)( QtWarningMsg, buf );
     } else {
 #ifdef Q_CC_MWERKS
 	vsprintf( buf, msg, ap );		// ### is there no vsnprintf()?
 	va_end( ap );
         mac_default_handler(buf);
 #else
 	vfprintf( stderr, msg, ap );
 	va_end( ap );
 	fprintf( stderr, "\n" );		// add newline
 #endif
     }
 }
 
 
 // again, copied
 void warning( const char *msg, ... )
 {
     char buf[QT_BUFFER_LENGTH];
     va_list ap;
     va_start( ap, msg );			// use variable arg list
     if ( handler ) {
 #if defined(QT_VSNPRINTF)
 	QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
 #else
 	vsprintf( buf, msg, ap );
 #endif
 	va_end( ap );
 	(*handler)( QtWarningMsg, buf );
     } else {
 #ifdef Q_CC_MWERKS
 	vsprintf( buf, msg, ap );		// ### is there no vsnprintf()?
 	va_end( ap );
         mac_default_handler(buf);
 #else
 	vfprintf( stderr, msg, ap );
 	va_end( ap );
 	fprintf( stderr, "\n" );		// add newline
 #endif
     }
 }
 
 void qFatal( const char *msg, ... )
 {
     char buf[QT_BUFFER_LENGTH];
     va_list ap;
     va_start( ap, msg );			// use variable arg list
     if ( handler ) {
 #if defined(QT_VSNPRINTF)
 	QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
 #else
 	vsprintf( buf, msg, ap );
 #endif
 	va_end( ap );
 	(*handler)( QtFatalMsg, buf );
     } else {
 #ifdef Q_CC_MWERKS
 	vsprintf( buf, msg, ap );		// ### is there no vsnprintf()?
 	va_end( ap );
         mac_default_handler(buf);
 #else
 	vfprintf( stderr, msg, ap );
 	va_end( ap );
 	fprintf( stderr, "\n" );		// add newline
 #endif
 #if defined(Q_OS_UNIX) && defined(QT_DEBUG)
 	abort();				// trap; generates core dump
 #else
 	exit( 1 );				// goodbye cruel world
 #endif
     }
 }
 
 // yet again, copied
 void fatal( const char *msg, ... )
 {
     char buf[QT_BUFFER_LENGTH];
     va_list ap;
     va_start( ap, msg );			// use variable arg list
     if ( handler ) {
 #if defined(QT_VSNPRINTF)
 	QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
 #else
 	vsprintf( buf, msg, ap );
 #endif
 	va_end( ap );
 	(*handler)( QtFatalMsg, buf );
     } else {
 #ifdef Q_CC_MWERKS
 	vsprintf( buf, msg, ap );		// ### is there no vsnprintf()?
 	va_end( ap );
         mac_default_handler(buf);
 #else
 	vfprintf( stderr, msg, ap );
 	va_end( ap );
 	fprintf( stderr, "\n" );		// add newline
 #endif
 #if defined(Q_OS_UNIX) && defined(QT_DEBUG)
 	abort();				// trap; generates core dump
 #else
 	exit( 1 );				// goodbye cruel world
 #endif
     }
 }
 
 /*!
   \relates QApplication
 
   Prints the message \a msg and uses \a code to get a system specific
   error message. When \a code is -1 (the default), the system's last
   error code will be used if possible. Use this method to handle
   failures in platform specific API calls.
 
   This function does nothing when Qt is built with \c QT_NO_DEBUG
   defined.
 */
 void qSystemWarning( const char* msg, int code )
 {
 #ifndef QT_NO_DEBUG
 #if defined(Q_OS_WIN32)
     if ( code == -1 )
 	code = GetLastError();
 
     if ( !code )
 	return;
 
 #ifdef Q_OS_TEMP
     unsigned short *string;
 
     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 			  NULL,
 			  code,
 			  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 			  (LPTSTR)&string,
 			  0,
 			  NULL );
 
     qWarning( "%s\n\tError code %d - %s (###may need fixing in qglobal.h)", msg, code, (const char *)string );
 #else
     char* string;
 
     FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 			  NULL,
 			  code,
 			  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 			  (char*)&string,
 			  0,
 			  NULL );
 
     qWarning( "%s\n\tError code %d - %s", msg, code, (const char*)string );
 #endif
 
     LocalFree( (HLOCAL)string );
 #else
     if ( code != -1 )
 	qWarning( "%s\n\tError code %d - %s", msg, code, strerror( code ) );
     else
 	qWarning( msg );
 #endif
 #endif
 }
 
 /*!
     \fn void Q_ASSERT( bool test )
 
     \relates QApplication
 
     Prints a warning message containing the source code file name and
     line number if \a test is FALSE.
 
     This is really a macro defined in \c qglobal.h.
 
     Q_ASSERT is useful for testing pre- and post-conditions.
 
     Example:
     \code
 	//
 	// File: div.cpp
 	//
 
 	#include <qglobal.h>
 
 	int divide( int a, int b )
 	{
 	    Q_ASSERT( b != 0 );			// this is line 9
 	    return a/b;
 	}
     \endcode
 
     If \c b is zero, the Q_ASSERT statement will output the following
     message using the qWarning() function:
     \code
 	ASSERT: "b == 0" in div.cpp (9)
     \endcode
 
     \sa qWarning(), \link debug.html Debugging\endlink
 */
 
 
 /*!
     \fn void Q_CHECK_PTR( void *p )
 
     \relates QApplication
 
-    If \a p is null, a fatal messages says that the program ran out of
-    memory and exits. If \e p is not null, nothing happens.
+    If \a p is 0, a fatal messages says that the program ran out of
+    memory and exits. If \e p is not 0, nothing happens.
 
     This is really a macro defined in \c qglobal.h.
 
     Example:
     \code
 	int *a;
 
 	Q_CHECK_PTR( a = new int[80] );  // WRONG!
 
-	a = new int[80];                 // Right
+	a = new (nothrow) int[80];       // Right
 	Q_CHECK_PTR( a );
     \endcode
 
     \sa qFatal(), \link debug.html Debugging\endlink
 */
 
 
 //
 // The Q_CHECK_PTR macro calls this function to check if an allocation went ok.
 //
 #if (QT_VERSION-0 >= 0x040000)
 #if defined(Q_CC_GNU)
 #warning "Change Q_CHECK_PTR to '{if ((p)==0) qt_check_pointer(__FILE__,__LINE__);}'"
 #warning "No need for qt_check_pointer() to return a value - make it void!"
 #endif
 #endif
 bool qt_check_pointer( bool c, const char *n, int l )
 {
     if ( c )
 	qWarning( "In file %s, line %d: Out of memory", n, l );
     return TRUE;
 }
 
 
 static bool firstObsoleteWarning(const char *obj, const char *oldfunc )
 {
     static QAsciiDict<int> *obsoleteDict = 0;
     if ( !obsoleteDict ) {			// first time func is called
 	obsoleteDict = new QAsciiDict<int>;
 #if defined(QT_DEBUG)
 	qDebug(
       "You are using obsolete functions in the Qt library. Call the function\n"
       "qSuppressObsoleteWarnings() to suppress obsolete warnings.\n"
 	     );
 #endif
     }
     QCString s( obj );
     s += "::";
     s += oldfunc;
     if ( obsoleteDict->find(s.data()) == 0 ) {
 	obsoleteDict->insert( s.data(), (int*)1 );	// anything different from 0
 	return TRUE;
     }
     return FALSE;
 }
 
 static bool suppressObsolete = FALSE;
 
 void qSuppressObsoleteWarnings( bool suppress )
 {
     suppressObsolete = suppress;
 }
 
 void qObsolete(	 const char *obj, const char *oldfunc, const char *newfunc )
 {
     if ( suppressObsolete )
 	return;
     if ( !firstObsoleteWarning(obj, oldfunc) )
 	return;
     if ( obj )
 	qDebug( "%s::%s: This function is obsolete, use %s instead.",
 	       obj, oldfunc, newfunc );
     else
 	qDebug( "%s: This function is obsolete, use %s instead.",
 	       oldfunc, newfunc );
 }
 
 void qObsolete(	 const char *obj, const char *oldfunc )
 {
     if ( suppressObsolete )
 	return;
     if ( !firstObsoleteWarning(obj, oldfunc) )
 	return;
     if ( obj )
 	qDebug( "%s::%s: This function is obsolete.", obj, oldfunc );
     else
 	qDebug( "%s: This function is obsolete.", oldfunc );
 }
 
 void qObsolete(	 const char *message )
 {
     if ( suppressObsolete )
 	return;
     if ( !firstObsoleteWarning( "Qt", message) )
 	return;
     qDebug( "%s", message );
 }
 
 
 /*!
     \relates QApplication
 
     Installs a Qt message handler \a h. Returns a pointer to the
     message handler previously defined.
 
     The message handler is a function that prints out debug messages,
     warnings and fatal error messages. The Qt library (debug version)
     contains hundreds of warning messages that are printed when
     internal errors (usually invalid function arguments) occur. If you
     implement your own message handler, you get total control of these
     messages.
 
     The default message handler prints the message to the standard
     output under X11 or to the debugger under Windows. If it is a
     fatal message, the application aborts immediately.
 
     Only one message handler can be defined, since this is usually
     done on an application-wide basis to control debug output.
 
     To restore the message handler, call \c qInstallMsgHandler(0).
 
     Example:
     \code
 	#include <qapplication.h>
 	#include <stdio.h>
 	#include <stdlib.h>
 
 	void myMessageOutput( QtMsgType type, const char *msg )
 	{
 	    switch ( type ) {
 		case QtDebugMsg:
 		    fprintf( stderr, "Debug: %s\n", msg );
 		    break;
 		case QtWarningMsg:
 		    fprintf( stderr, "Warning: %s\n", msg );
 		    break;
 		case QtFatalMsg:
 		    fprintf( stderr, "Fatal: %s\n", msg );
 		    abort();			// deliberately core dump
 	    }
 	}
 
 	int main( int argc, char **argv )
 	{
 	    qInstallMsgHandler( myMessageOutput );
 	    QApplication a( argc, argv );
 	    ...
 	    return a.exec();
 	}
     \endcode
 
     \sa qDebug(), qWarning(), qFatal(), \link debug.html Debugging\endlink
 */
 
 QtMsgHandler qInstallMsgHandler( QtMsgHandler h )
 {
     QtMsgHandler old = handler;
     handler = h;
     return old;
 }
 
 
 /*
     Dijkstra's bisection algorithm to find the square root as an integer.
     Deliberately not exported as part of the Qt API, but used in both
     qsimplerichtext.cpp and qgfxraster_qws.cpp
 */
 unsigned int qt_int_sqrt( unsigned int n )
 {
     // n must be in the range 0...UINT_MAX/2-1
     if ( n >= ( UINT_MAX>>2 ) ) {
 	unsigned int r = 2 * qt_int_sqrt( n / 4 );
 	unsigned int r2 = r + 1;
 	return ( n >= r2 * r2 ) ? r2 : r;
     }
     uint h, p= 0, q= 1, r= n;
     while ( q <= n )
         q <<= 2;
     while ( q != 1 ) {
         q >>= 2;
         h= p + q;
         p >>= 1;
         if ( r >= h ) {
             p += q;
             r -= h;
         }
     }
     return p;
 }
 
diff --git a/qmake/tools/qgpluginmanager.cpp b/qmake/tools/qgpluginmanager.cpp
index 46c85f5..72246ac 100644
--- a/qmake/tools/qgpluginmanager.cpp
+++ b/qmake/tools/qgpluginmanager.cpp
@@ -1,544 +1,544 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QGPluginManager class
 **
-** Copyright (C) 2000-2001 Trolltech AS.  All rights reserved.
+** Copyright (C) 2000-2003 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qgpluginmanager_p.h"
 #ifndef QT_NO_COMPONENT
 #include "qcomlibrary_p.h"
 #include "qmap.h"
 #include "qdir.h"
 
 /*
   The following co-occurrence code is borrowed from Qt Linguist.
 
   How similar are two texts? The approach used here relies on
   co-occurrence matrices and is very efficient.
 
   Let's see with an example: how similar are "here" and "hither"?  The
   co-occurrence matrix M for "here" is M[h,e] = 1, M[e,r] = 1,
   M[r,e] = 1 and 0 elsewhere; the matrix N for "hither" is N[h,i] = 1,
   N[i,t] = 1, ..., N[h,e] = 1, N[e,r] = 1 and 0 elsewhere.  The union
   U of both matrices is the matrix U[i,j] = max { M[i,j], N[i,j] },
   and the intersection V is V[i,j] = min { M[i,j], N[i,j] }. The score
   for a pair of texts is
 
       score = (sum of V[i,j] over all i, j) / (sum of U[i,j] over all i, j),
 
   a formula suggested by Arnt Gulbrandsen. Here we have
 
       score = 2 / 6,
 
   or one third.
 
   The implementation differs from this in a few details.  Most
   importantly, repetitions are ignored; for input "xxx", M[x,x] equals
   1, not 2.
 */
 
 /*
   Every character is assigned to one of 20 buckets so that the
   co-occurrence matrix requires only 20 * 20 = 400 bits, not
   256 * 256 = 65536 bits or even more if we want the whole Unicode.
   Which character falls in which bucket is arbitrary.
 
   The second half of the table is a replica of the first half, because of
   laziness.
 */
 static const char indexOf[256] = {
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 //      !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /
     0,  2,  6,  7,  10, 12, 15, 19, 2,  6,  7,  10, 12, 15, 19, 0,
 //  0   1   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?
     1,  3,  4,  5,  8,  9,  11, 13, 14, 16, 2,  6,  7,  10, 12, 15,
 //  @   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
 //  P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _
     15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0,
 //  `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
 //  p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~
     15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0,
 
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  2,  6,  7,  10, 12, 15, 19, 2,  6,  7,  10, 12, 15, 19, 0,
     1,  3,  4,  5,  8,  9,  11, 13, 14, 16, 2,  6,  7,  10, 12, 15,
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
     15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0,
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
     15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0
 };
 
 /*
   The entry bitCount[i] (for i between 0 and 255) is the number of
   bits used to represent i in binary.
 */
 static const char bitCount[256] = {
     0,  1,  1,  2,  1,  2,  2,  3,  1,  2,  2,  3,  2,  3,  3,  4,
     1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
     1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
     2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
     1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
     2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
     2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
     3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
     1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
     2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
     2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
     3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
     2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
     3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
     3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
     4,  5,  5,  6,  5,  6,  6,  7,  5,  6,  6,  7,  6,  7,  7,  8
 };
 
 class QCoMatrix
 {
 public:
     /*
       The matrix has 20 * 20 = 400 entries. This requires 50 bytes, or
       13 words. Some operations are performed on words for more
       efficiency.
     */
     union {
 	Q_UINT8 b[52];
 	Q_UINT32 w[13];
     };
 
     QCoMatrix() { memset( b, 0, 52 ); }
     QCoMatrix( const char *text ) {
 	char c = '\0', d;
 	memset( b, 0, 52 );
 	while ( (d = *text) != '\0' ) {
 	    setCoocc( c, d );
 	    if ( (c = *++text) != '\0' ) {
 		setCoocc( d, c );
 		text++;
 	    }
 	}
     }
 
     void setCoocc( char c, char d ) {
 	int k = indexOf[(uchar) c] + 20 * indexOf[(uchar) d];
 	b[k >> 3] |= k & 0x7;
     }
 
     int worth() const {
 	int result = 0;
 	for ( int i = 0; i < 50; i++ )
 	    result += bitCount[b[i]];
 	return result;
     }
 
     static QCoMatrix reunion( const QCoMatrix& m, const QCoMatrix& n )
     {
 	QCoMatrix p;
 	for ( int i = 0; i < 13; i++ )
 	    p.w[i] = m.w[i] | n.w[i];
 	return p;
     }
     static QCoMatrix intersection( const QCoMatrix& m, const QCoMatrix& n )
     {
 	QCoMatrix p;
 	for ( int i = 0; i < 13; i++ )
 	    p.w[i] = m.w[i] & n.w[i];
 	return p;
     }
 };
 
 /*
   Returns an integer between 0 (dissimilar) and 15 (very similar)
   depending on  how similar the string is to \a target.
 
   This function is efficient, but its results might change in future
   versions of Qt as the algorithm evolves.
 
   \code
     QString s( "color" );
     a = similarity( s, "color" );  // a == 15
     a = similarity( s, "colour" ); // a == 8
     a = similarity( s, "flavor" ); // a == 4
     a = similarity( s, "dahlia" ); // a == 0
   \endcode
 */
 static int similarity( const QString& s1, const QString& s2 )
 {
     QCoMatrix m1( s1 );
     QCoMatrix m2( s2 );
     return ( 15 * (QCoMatrix::intersection(m1, m2).worth() + 1) ) /
 	   ( QCoMatrix::reunion(m1, m2).worth() + 1 );
 }
 
 /*!
   \class QPluginManager qpluginmanager.h
   \reentrant
   \brief The QPluginManager class provides basic functions to access a certain kind of functionality in libraries.
   \ingroup componentmodel
 
   \internal
 
   A common usage of components is to extend the existing functionality in an application using plugins. The application
   defines interfaces that abstract a certain group of functionality, and a plugin provides a specialized implementation
   of one or more of those interfaces.
 
   The QPluginManager template has to be instantiated with an interface definition and the IID for this interface.
 
   \code
   QPluginManager<MyPluginInterface> *manager = new QPluginManager<MyPluginInterface>( IID_MyPluginInterface );
   \endcode
 
   It searches a specified directory for all shared libraries, queries for components that implement the specific interface and
   reads information about the features the plugin wants to add to the application. The component can provide the set of features
   provided by implementing either the QFeatureListInterface or the QComponentInformationInterface. The strings returned by the implementations
   of
 
   \code
   QStringList QFeatureListInterface::featureList() const
   \endcode
 
   or
 
   \code
   QString QComponentInformationInterface::name() const
   \endcode
 
   respectively, can then be used to access the component that provides the requested feature:
 
   \code
   MyPluginInterface *iface;
   manager->queryInterface( "feature", &iface );
   if ( iface )
       iface->execute( "feature" );
   \endcode
 
   The application can use a QPluginManager instance to create parts of the user interface based on the list of features
   found in plugins:
 
   \code
   QPluginManager<MyPluginInterface> *manager = new QPluginManager<MyPluginInterface>( IID_ImageFilterInterface );
   manager->addLibraryPath(...);
 
   QStringList features = manager->featureList();
   for ( QStringList::Iterator it = features.begin(); it != features.end(); ++it ) {
       MyPluginInterface *iface;
       manager->queryInterface( *it, &iface );
 
       // use QAction to provide toolbuttons and menuitems for each feature...
   }
   \endcode
 */
 
 /*!
   \fn QPluginManager::QPluginManager( const QUuid& id, const QStringList& paths = QString::null, const QString &suffix = QString::null, bool cs = TRUE )
 
   Creates an QPluginManager for interfaces \a id that will load all shared library files in the \a paths + \a suffix.
   If \a cs is FALSE the manager will handle feature strings case insensitive.
 
   \warning
   Setting the cs flag to FALSE requires that components also convert to lower case when comparing with passed strings, so this has
   to be handled with care and documented very well.
 
   \sa QApplication::libraryPaths()
 */
 
 
 /*!
   \fn QRESULT QPluginManager::queryInterface(const QString& feature, Type** iface) const
 
   Sets \a iface to point to the interface providing \a feature.
 
   \sa featureList(), library()
 */
 
 
 
 #include <qptrlist.h>
 
 QGPluginManager::QGPluginManager( const QUuid& id, const QStringList& paths, const QString &suffix, bool cs )
     : interfaceId( id ), plugDict( 17, cs ), casesens( cs ), autounload( TRUE )
 {
     // Every QLibrary object is destroyed on destruction of the manager
     libDict.setAutoDelete( TRUE );
     for ( QStringList::ConstIterator it = paths.begin(); it != paths.end(); ++it ) {
 	QString path = *it;
 	addLibraryPath( path + suffix );
     }
 }
 
 QGPluginManager::~QGPluginManager()
 {
     if ( !autounload ) {
 	QDictIterator<QLibrary> it( libDict );
 	while ( it.current() ) {
 	    QLibrary *lib = it.current();
 	    ++it;
 	    lib->setAutoUnload( FALSE );
 	}
     }
 }
 
 void QGPluginManager::addLibraryPath( const QString& path )
 {
     if ( !enabled() || !QDir( path ).exists( ".", TRUE ) )
 	return;
 
 #if defined(Q_OS_WIN32)
     QString filter = "dll";
 #elif defined(Q_OS_MACX)
     QString filter = "dylib";
 #elif defined(Q_OS_UNIX)
     QString filter = "so";
 #endif
 
     QStringList plugins = QDir(path).entryList( "*." + filter );
     for ( QStringList::Iterator p = plugins.begin(); p != plugins.end(); ++p ) {
 	QString lib = QDir::cleanDirPath( path + "/" + *p );
 	if ( libList.contains( lib ) )
 	    continue;
 	libList.append( lib );
     }
 }
 
 const QLibrary* QGPluginManager::library( const QString& feature ) const
 {
     if ( !enabled() || feature.isEmpty() )
 	return 0;
 
     // We already have a QLibrary object for this feature
     QLibrary *library = 0;
     if ( ( library = plugDict[feature] ) )
 	return library;
 
     // Find the filename that matches the feature request best
     QMap<int, QStringList> map;
     QStringList::ConstIterator it = libList.begin();
     int best = 0;
     int worst = 15;
     while ( it != libList.end() ) {
 	if ( (*it).isEmpty() || libDict[*it] ) {
 	    ++it;
 	    continue;
 	}
 	QString basename = QFileInfo(*it).baseName();
 	int s = similarity( feature, basename );
 	if ( s < worst )
 	    worst = s;
 	if ( s > best )
 	    best = s;
 	map[s].append( basename + QChar(0xfffd) + *it );
 	++it;
     }
 
     if ( map.isEmpty() )
 	return 0; // no libraries to add
 
     // Start with the best match to get the library object
     QGPluginManager *that = (QGPluginManager*)this;
     for ( int s = best; s >= worst; --s ) {
 	QStringList group = map[s];
 	group.sort(); // sort according to the base name
 	QStringList::ConstIterator git = group.begin();
 	while ( git != group.end() ) {
 	    QString lib = (*git).mid( (*git).find( QChar(0xfffd) ) + 1 );
 	    QString basename = (*git).left( (*git).find( QChar(0xfffd) ) );
 	    ++git;
 
 	    QStringList sameBasename;
 	    while( git != group.end() &&
 		   basename == (*git).left( (*git).find( QChar(0xfffd) ) )  ) {
 		sameBasename << (*git).mid( (*git).find( QChar(0xfffd) ) + 1 );
 		++git;
 	    }
 
 	    if ( sameBasename.isEmpty() ) {
 		that->addLibrary( new QComLibrary( lib ) );
 	    } else {
 		QPtrList<QComLibrary> same;
 		same.setAutoDelete( TRUE );
 		for ( QStringList::ConstIterator bit = sameBasename.begin();
 		      bit != sameBasename.end(); ++bit )
 		    same.append( new QComLibrary( *bit ) );
 		QComLibrary* bestMatch = 0;
 		for ( QComLibrary* candidate = same.first(); candidate; candidate = same.next() )
 		    if ( candidate->qtVersion() && candidate->qtVersion() <= QT_VERSION
 			 && ( !bestMatch || candidate->qtVersion() > bestMatch->qtVersion() ) )
 			bestMatch = candidate;
 		if ( bestMatch ) {
 		    same.find( bestMatch );
 		    that->addLibrary( same.take() );
 		}
 	    }
 
 	    if ( ( library = that->plugDict[feature] ) )
 		return library;
 	}
     }
     return 0;
 }
 
 QStringList QGPluginManager::featureList() const
 {
     QStringList features;
 
     if ( !enabled() )
 	return features;
 
     QGPluginManager *that = (QGPluginManager*)this;
     QStringList theLibs = libList;
     QStringList phase2Libs;
     QStringList phase2Deny;
 
     /* In order to get the feature list we need to add all interesting
       libraries. If there are libraries with the same base name, we
       prioritze the one that fits our Qt version number and ignore the
       others  */
     QStringList::Iterator it;
     for ( it = theLibs.begin(); it != theLibs.end(); ++it  ) {
 	if ( (*it).isEmpty() || libDict[*it] )
 	    continue;
 	QComLibrary* library = new QComLibrary( *it );
 	if ( library->qtVersion() == QT_VERSION ) {
 	    that->addLibrary( library );
 	    phase2Deny << QFileInfo( *it ).baseName();
 	} else {
 	    delete library;
 	    phase2Libs << *it;
 	}
     }
     for ( it = phase2Libs.begin(); it != phase2Libs.end(); ++it  )
 	if ( !phase2Deny.contains( QFileInfo( *it ).baseName() ) )
 	    that->addLibrary( new QComLibrary( *it ) );
 
     for ( QDictIterator<QLibrary> pit( plugDict ); pit.current(); ++pit )
 	features << pit.currentKey();
 
     return features;
 }
 
 bool QGPluginManager::addLibrary( QLibrary* lib )
 {
     if ( !enabled() || !lib )
 	return FALSE;
 
     QComLibrary* plugin = (QComLibrary*)lib;
     bool useful = FALSE;
 
     QUnknownInterface* iFace = 0;
     plugin->queryInterface( interfaceId, &iFace );
     if ( iFace ) {
 	QFeatureListInterface *fliFace = 0;
 	QComponentInformationInterface *cpiFace = 0;
 	iFace->queryInterface( IID_QFeatureList, (QUnknownInterface**)&fliFace );
 	if ( !fliFace )
 	    plugin->queryInterface( IID_QFeatureList, (QUnknownInterface**)&fliFace );
 	if ( !fliFace ) {
 	    iFace->queryInterface( IID_QComponentInformation, (QUnknownInterface**)&cpiFace );
 	    if ( !cpiFace )
 		plugin->queryInterface( IID_QComponentInformation, (QUnknownInterface**)&cpiFace );
 	}
 	QStringList fl;
 	if ( fliFace )
 	    // Map all found features to the library
 	    fl = fliFace->featureList();
 	else if ( cpiFace )
 	    fl << cpiFace->name();
 
-	for ( QStringList::Iterator f = fl.begin(); f != fl.end(); f++ ) {
+	for ( QStringList::Iterator f = fl.begin(); f != fl.end(); ++f ) {
 	    QLibrary *old = plugDict[*f];
 	    if ( !old ) {
 		useful = TRUE;
 		plugDict.replace( *f, plugin );
 	    } else {
 		// we have old *and* plugin, which one to pick?
 		QComLibrary* first = (QComLibrary*)old;
 		QComLibrary* second = (QComLibrary*)plugin;
 		bool takeFirst = TRUE;
 		if ( first->qtVersion() != QT_VERSION ) {
 		    if ( second->qtVersion() == QT_VERSION )
 			takeFirst = FALSE;
 		    else if ( second->qtVersion() < QT_VERSION &&
 			      first->qtVersion() > QT_VERSION )
 			takeFirst = FALSE;
 		}
 		if ( !takeFirst ) {
 		    useful = TRUE;
 		    plugDict.replace( *f, plugin );
 		    qWarning("%s: Discarding feature %s in %s!",
 			     (const char*) QFile::encodeName( plugin->library()),
 			     (*f).latin1(),
 			     (const char*) QFile::encodeName( old->library() ) );
 		} else {
 		    qWarning("%s: Feature %s already defined in %s!",
 			     (const char*) QFile::encodeName( old->library() ),
 			     (*f).latin1(),
 			     (const char*) QFile::encodeName( plugin->library() ) );
 		}
 	    }
 	}
 	if ( fliFace )
 	    fliFace->release();
 	if ( cpiFace )
 	    cpiFace->release();
 	iFace->release();
     }
 
     if ( useful ) {
 	libDict.replace( plugin->library(), plugin );
 	if ( !libList.contains( plugin->library() ) )
 	    libList.append( plugin->library() );
 	return TRUE;
     }
     delete plugin;
     return FALSE;
 }
 
 
 bool QGPluginManager::enabled() const
 {
 #ifdef QT_SHARED
     return TRUE;
 #else
     return FALSE;
 #endif
 }
 
 QRESULT QGPluginManager::queryUnknownInterface(const QString& feature, QUnknownInterface** iface) const
 {
     QComLibrary* plugin = 0;
     plugin = (QComLibrary*)library( feature );
     return plugin ? plugin->queryInterface( interfaceId, (QUnknownInterface**)iface ) : QE_NOINTERFACE;
 }
 
 #endif //QT_NO_COMPONENT
diff --git a/qmake/tools/qgvector.cpp b/qmake/tools/qgvector.cpp
index 1985f03..3c903ed 100644
--- a/qmake/tools/qgvector.cpp
+++ b/qmake/tools/qgvector.cpp
@@ -1,584 +1,591 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QGVector class
 **
 ** Created : 930907
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
+#include "qglobal.h"
+#if defined(Q_CC_BOR)
+// needed for qsort() because of a std namespace problem on Borland
+#include "qplatformdefs.h"
+#endif
+
 #define	 QGVECTOR_CPP
 #include "qgvector.h"
 #include "qglist.h"
 #include "qstring.h"
 #include "qdatastream.h"
 #include <stdlib.h>
 
 #ifdef QT_THREAD_SUPPORT
 #  include <private/qmutexpool_p.h>
 #endif // QT_THREAD_SUPPORT
 
 #define USE_MALLOC				// comment to use new/delete
 
 #undef NEW
 #undef DELETE
 
 #if defined(USE_MALLOC)
 #define NEW(type,size)	((type*)malloc(size*sizeof(type)))
 #define DELETE(array)	(free((char*)array))
 #else
 #define NEW(type,size)	(new type[size])
 #define DELETE(array)	(delete[] array)
 #define DONT_USE_REALLOC			// comment to use realloc()
 #endif
 
 /*!
   \class QGVector
   \reentrant
   \ingroup collection
 
   \brief The QGVector class is an internal class for implementing Qt
   collection classes.
 
   \internal
 
   QGVector is an internal class that acts as a base class for the
   QPtrVector collection class.
 
   QGVector has some virtual functions that may be reimplemented in
   subclasses to customize behavior.
 
   \list
   \i compareItems() compares two collection/vector items.
   \i read() reads a collection/vector item from a QDataStream.
   \i write() writes a collection/vector item to a QDataStream.
   \endlist
 */
 
 /*****************************************************************************
   Default implementation of virtual functions
  *****************************************************************************/
 
 /*!
   This virtual function compares two list items.
 
   Returns:
   <ul>
   <li> 0 if \a d1 == \a d2
   <li> non-zero if \a d1 != \a d2
   </ul>
 
   This function returns \e int rather than \e bool so that
   reimplementations can return one of three values and use it to sort
   by:
   <ul>
   <li> 0 if \a d1 == \a d2
   <li> \> 0 (positive integer) if \a d1 \> \a d2
   <li> \< 0 (negative integer) if \a d1 \< \a d2
   </ul>
 
   The QPtrVector::sort() and QPtrVector::bsearch() functions require that
   compareItems() is implemented as described here.
 
   This function should not modify the vector because some const
   functions call compareItems().
 */
 
 int QGVector::compareItems( Item d1, Item d2 )
 {
     return d1 != d2;				// compare pointers
 }
 
 #ifndef QT_NO_DATASTREAM
 /*!
   Reads a collection/vector item from the stream \a s and returns a reference
   to the stream.
 
   The default implementation sets \a d to 0.
 
   \sa write()
 */
 
 QDataStream &QGVector::read( QDataStream &s, Item &d )
 {						// read item from stream
     d = 0;
     return s;
 }
 
 /*!
   Writes a collection/vector item to the stream \a s and returns a reference
   to the stream.
 
   The default implementation does nothing.
 
   \sa read()
 */
 
 QDataStream &QGVector::write( QDataStream &s, Item ) const
 {						// write item to stream
     return s;
 }
 #endif // QT_NO_DATASTREAM
 
 /*****************************************************************************
   QGVector member functions
  *****************************************************************************/
 
 QGVector::QGVector()				// create empty vector
 {
     vec = 0;
     len = numItems = 0;
 }
 
 QGVector::QGVector( uint size )			// create vectors with nullptrs
 {
     len = size;
     numItems = 0;
     if ( len == 0 ) {				// zero length
 	vec = 0;
 	return;
     }
     vec = NEW(Item,len);
     Q_CHECK_PTR( vec );
     memset( (void*)vec, 0, len*sizeof(Item) );	// fill with nulls
 }
 
 QGVector::QGVector( const QGVector &a )		// make copy of other vector
     : QPtrCollection( a )
 {
     len = a.len;
     numItems = a.numItems;
     if ( len == 0 ) {
 	vec = 0;
 	return;
     }
     vec = NEW( Item, len );
     Q_CHECK_PTR( vec );
     for ( uint i = 0; i < len; i++ ) {
 	if ( a.vec[i] ) {
 	    vec[i] = newItem( a.vec[i] );
 	    Q_CHECK_PTR( vec[i] );
 	} else {
 	    vec[i] = 0;
 	}
     }
 }
 
 QGVector::~QGVector()
 {
     clear();
 }
 
 QGVector& QGVector::operator=( const QGVector &v )
 {
     if ( &v == this )
 	return *this;
 
     clear();
     len = v.len;
     numItems = v.numItems;
     if ( len == 0 ) {
 	vec = 0;
 	return *this;
     }
     vec = NEW( Item, len );
     Q_CHECK_PTR( vec );
     for ( uint i = 0; i < len; i++ ) {
 	if ( v.vec[i] ) {
 	    vec[i] = newItem( v.vec[i] );
 	    Q_CHECK_PTR( vec[i] );
 	} else {
 	    vec[i] = 0;
 	}
     }
     return *this;
 }
 
 
 bool QGVector::insert( uint index, Item d )	// insert item at index
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= len ) {			// range error
 	qWarning( "QGVector::insert: Index %d out of range", index );
 	return FALSE;
     }
 #endif
     if ( vec[index] ) {				// remove old item
 	deleteItem( vec[index] );
 	numItems--;
     }
     if ( d ) {
 	vec[index] = newItem( d );
 	Q_CHECK_PTR( vec[index] );
 	numItems++;
 	return vec[index] != 0;
     } else {
 	vec[index] = 0;				// reset item
     }
     return TRUE;
 }
 
 bool QGVector::remove( uint index )		// remove item at index
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= len ) {			// range error
 	qWarning( "QGVector::remove: Index %d out of range", index );
 	return FALSE;
     }
 #endif
     if ( vec[index] ) {				// valid item
 	deleteItem( vec[index] );		// delete it
 	vec[index] = 0;				// reset pointer
 	numItems--;
     }
     return TRUE;
 }
 
 QPtrCollection::Item QGVector::take( uint index )		// take out item
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= len ) {			// range error
 	qWarning( "QGVector::take: Index %d out of range", index );
 	return 0;
     }
 #endif
     Item d = vec[index];				// don't delete item
     if ( d )
 	numItems--;
     vec[index] = 0;
     return d;
 }
 
 void QGVector::clear()				// clear vector
 {
     if ( vec ) {
 	for ( uint i=0; i<len; i++ ) {		// delete each item
 	    if ( vec[i] )
 		deleteItem( vec[i] );
 	}
 	DELETE(vec);
 	vec = 0;
 	len = numItems = 0;
     }
 }
 
 bool QGVector::resize( uint newsize )		// resize array
 {
     if ( newsize == len )			// nothing to do
 	return TRUE;
     if ( vec ) {				// existing data
 	if ( newsize < len ) {			// shrink vector
 	    uint i = newsize;
 	    while ( i < len ) {			// delete lost items
 		if ( vec[i] ) {
 		    deleteItem( vec[i] );
 		    numItems--;
 		}
 		i++;
 	    }
 	}
 	if ( newsize == 0 ) {			// vector becomes empty
 	    DELETE(vec);
 	    vec = 0;
 	    len = numItems = 0;
 	    return TRUE;
 	}
 #if defined(DONT_USE_REALLOC)
 	if ( newsize == 0 ) {
 	    DELETE(vec);
 	    vec = 0;
 	    return FALSE;
 	}
 	Item *newvec = NEW(Item,newsize);		// manual realloc
 	memcpy( newvec, vec, (len < newsize ? len : newsize)*sizeof(Item) );
 	DELETE(vec);
 	vec = newvec;
 #else
 	vec = (Item*)realloc( (char *)vec, newsize*sizeof(Item) );
 #endif
     } else {					// create new vector
 	vec = NEW(Item,newsize);
 	len = numItems = 0;
     }
     Q_CHECK_PTR( vec );
     if ( !vec )					// no memory
 	return FALSE;
     if ( newsize > len )			// init extra space added
 	memset( (void*)&vec[len], 0, (newsize-len)*sizeof(Item) );
     len = newsize;
     return TRUE;
 }
 
 
 bool QGVector::fill( Item d, int flen )		// resize and fill vector
 {
     if ( flen < 0 )
 	flen = len;				// default: use vector length
     else if ( !resize( flen ) )
 	return FALSE;
     for ( uint i=0; i<(uint)flen; i++ )		// insert d at every index
 	insert( i, d );
     return TRUE;
 }
 
 
 static QGVector *sort_vec=0;			// current sort vector
 
 
 #if defined(Q_C_CALLBACKS)
 extern "C" {
 #endif
 
 #ifdef Q_OS_TEMP
 static int _cdecl cmp_vec( const void *n1, const void *n2 )
 #else
 static int cmp_vec( const void *n1, const void *n2 )
 #endif
 {
     return sort_vec->compareItems( *((QPtrCollection::Item*)n1), *((QPtrCollection::Item*)n2) );
 }
 
 #if defined(Q_C_CALLBACKS)
 }
 #endif
 
 
 void QGVector::sort()				// sort vector
 {
     if ( count() == 0 )				// no elements
 	return;
     register Item *start = &vec[0];
     register Item *end	= &vec[len-1];
     Item tmp;
     for (;;) {				// put all zero elements behind
 	while ( start < end && *start != 0 )
 	    start++;
 	while ( end > start && *end == 0 )
 	    end--;
 	if ( start < end ) {
 	    tmp = *start;
 	    *start = *end;
 	    *end = tmp;
 	} else {
 	    break;
 	}
     }
 
 #ifdef QT_THREAD_SUPPORT
-    QMutexLocker locker( qt_global_mutexpool->get( &sort_vec ) );
+    QMutexLocker locker( qt_global_mutexpool ?
+			 qt_global_mutexpool->get( &sort_vec ) : 0 );
 #endif // QT_THREAD_SUPPORT
 
     sort_vec = (QGVector*)this;
     qsort( vec, count(), sizeof(Item), cmp_vec );
     sort_vec = 0;
 }
 
 int QGVector::bsearch( Item d ) const		// binary search; when sorted
 {
     if ( !len )
 	return -1;
     if ( !d ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QGVector::bsearch: Cannot search for null object" );
 #endif
 	return -1;
     }
     int n1 = 0;
     int n2 = len - 1;
     int mid = 0;
     bool found = FALSE;
     while ( n1 <= n2 ) {
 	int  res;
 	mid = (n1 + n2)/2;
 	if ( vec[mid] == 0 )			// null item greater
 	    res = -1;
 	else
 	    res = ((QGVector*)this)->compareItems( d, vec[mid] );
 	if ( res < 0 )
 	    n2 = mid - 1;
 	else if ( res > 0 )
 	    n1 = mid + 1;
 	else {					// found it
 	    found = TRUE;
 	    break;
 	}
     }
     if ( !found )
 	return -1;
     // search to first of equal items
     while ( (mid - 1 >= 0) && !((QGVector*)this)->compareItems(d, vec[mid-1]) )
 	mid--;
     return mid;
 }
 
 int QGVector::findRef( Item d, uint index) const // find exact item in vector
 {
 #if defined(QT_CHECK_RANGE)
     if ( index > len ) {			// range error
 	qWarning( "QGVector::findRef: Index %d out of range", index );
 	return -1;
     }
 #endif
     for ( uint i=index; i<len; i++ ) {
 	if ( vec[i] == d )
 	    return i;
     }
     return -1;
 }
 
 int QGVector::find( Item d, uint index ) const	// find equal item in vector
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= len ) {			// range error
 	qWarning( "QGVector::find: Index %d out of range", index );
 	return -1;
     }
 #endif
     for ( uint i=index; i<len; i++ ) {
 	if ( vec[i] == 0 && d == 0 )		// found null item
 	    return i;
 	if ( vec[i] && ((QGVector*)this)->compareItems( vec[i], d ) == 0 )
 	    return i;
     }
     return -1;
 }
 
 uint QGVector::containsRef( Item d ) const	// get number of exact matches
 {
     uint count = 0;
     for ( uint i=0; i<len; i++ ) {
 	if ( vec[i] == d )
 	    count++;
     }
     return count;
 }
 
 uint QGVector::contains( Item d ) const		// get number of equal matches
 {
     uint count = 0;
     for ( uint i=0; i<len; i++ ) {
 	if ( vec[i] == 0 && d == 0 )		// count null items
 	    count++;
 	if ( vec[i] && ((QGVector*)this)->compareItems( vec[i], d ) == 0 )
 	    count++;
     }
     return count;
 }
 
 bool QGVector::insertExpand( uint index, Item d )// insert and grow if necessary
 {
     if ( index >= len ) {
 	if ( !resize( index+1 ) )		// no memory
 	    return FALSE;
     }
     insert( index, d );
     return TRUE;
 }
 
 void QGVector::toList( QGList *list ) const	// store items in list
 {
     list->clear();
     for ( uint i=0; i<len; i++ ) {
 	if ( vec[i] )
 	    list->append( vec[i] );
     }
 }
 
 
 void QGVector::warningIndexRange( uint i )
 {
 #if defined(QT_CHECK_RANGE)
     qWarning( "QGVector::operator[]: Index %d out of range", i );
 #else
     Q_UNUSED( i )
 #endif
 }
 
 
 /*****************************************************************************
   QGVector stream functions
  *****************************************************************************/
 #ifndef QT_NO_DATASTREAM
 QDataStream &operator>>( QDataStream &s, QGVector &vec )
 {						// read vector
     return vec.read( s );
 }
 
 QDataStream &operator<<( QDataStream &s, const QGVector &vec )
 {						// write vector
     return vec.write( s );
 }
 
 QDataStream &QGVector::read( QDataStream &s )	// read vector from stream
 {
     uint num;
     s >> num;					// read number of items
     clear();					// clear vector
     resize( num );
     for (uint i=0; i<num; i++) {		// read all items
 	Item d;
 	read( s, d );
 	Q_CHECK_PTR( d );
 	if ( !d )				// no memory
 	    break;
 	vec[i] = d;
     }
     return s;
 }
 
 QDataStream &QGVector::write( QDataStream &s ) const
 {						// write vector to stream
     uint num = count();
     s << num;					// number of items to write
     num = size();
     for (uint i=0; i<num; i++) {		// write non-null items
 	if ( vec[i] )
 	    write( s, vec[i] );
     }
     return s;
 }
 
 /* Returns whether v equals this vector or not */
 
 bool QGVector::operator==( const QGVector &v ) const
 {
     if ( size() != v.size() )
 	return FALSE;
     if ( count() != v.count() )
 	return FALSE;
     for ( int i = 0; i < (int)size(); ++i ) {
 	if ( ( (QGVector*)this )->compareItems( at( i ), v.at( i ) ) != 0 )
 	    return FALSE;
     }
     return TRUE;
 }
 
 #endif // QT_NO_DATASTREAM
diff --git a/qmake/tools/qlibrary.cpp b/qmake/tools/qlibrary.cpp
index 564db30..be1d54b 100644
--- a/qmake/tools/qlibrary.cpp
+++ b/qmake/tools/qlibrary.cpp
@@ -1,343 +1,344 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QLibrary class
 **
-** Created : 2000-01-01
+** Created : 000101
 **
-** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
+** Copyright (C) 2000-2003 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qplatformdefs.h"
 #include <private/qlibrary_p.h>
 
 #ifndef QT_NO_LIBRARY
 
 // uncomment this to get error messages
 //#define QT_DEBUG_COMPONENT 1
 // uncomment this to get error and success messages
 //#define QT_DEBUG_COMPONENT 2
 
 #ifndef QT_DEBUG_COMPONENT
 # if defined(QT_DEBUG)
 #  define QT_DEBUG_COMPONENT 1
 # endif
 #endif
 
 #if defined(QT_DEBUG_COMPONENT)
 #include <qfile.h>
 #endif
 
 #if defined(Q_WS_WIN) && !defined(QT_MAKEDLL)
 #define QT_NO_LIBRARY_UNLOAD
 #endif
 
 QLibraryPrivate::QLibraryPrivate( QLibrary *lib )
     : pHnd( 0 ), library( lib )
 {
 }
 
 
 /*!
     \class QLibrary qlibrary.h
     \reentrant
     \brief The QLibrary class provides a wrapper for handling shared libraries.
 
     \mainclass
-    \group plugins
+    \ingroup plugins
 
     An instance of a QLibrary object can handle a single shared
     library and provide access to the functionality in the library in
     a platform independent way. If the library is a component server,
     QLibrary provides access to the exported component and can
     directly query this component for interfaces.
 
     QLibrary ensures that the shared library is loaded and stays in
     memory whilst it is in use. QLibrary can also unload the library
     on destruction and release unused resources.
 
     A typical use of QLibrary is to resolve an exported symbol in a
     shared object, and to call the function that this symbol
     represents. This is called "explicit linking" in contrast to
     "implicit linking", which is done by the link step in the build
     process when linking an executable against a library.
 
     The following code snippet loads a library, resolves the symbol
     "mysymbol", and calls the function if everything succeeded. If
     something went wrong, e.g. the library file does not exist or the
     symbol is not defined, the function pointer will be 0 and won't be
     called. When the QLibrary object is destroyed the library will be
     unloaded, making all references to memory allocated in the library
     invalid.
 
     \code
     typedef void (*MyPrototype)();
     MyPrototype myFunction;
 
     QLibrary myLib( "mylib" );
     myFunction = (MyProtoype) myLib.resolve( "mysymbol" );
     if ( myFunction ) {
 	myFunction();
     }
     \endcode
 */
 
 /*!
     Creates a QLibrary object for the shared library \a filename. The
     library will be unloaded in the destructor.
 
     Note that \a filename does not need to include the (platform specific)
     file extension, so calling
     \code
     QLibrary lib( "mylib" );
     \endcode
     is equivalent to calling
     \code
     QLibrary lib( "mylib.dll" );
     \endcode
     on Windows, and
     \code
     QLibrary lib( "libmylib.so" );
     \endcode
     on Unix. Specifying the extension is not recommended, since
     doing so introduces a platform dependency.
 
     If \a filename does not include a path, the library loader will
     look for the file in the platform specific search paths.
 
     \sa load() unload(), setAutoUnload()
 */
 QLibrary::QLibrary( const QString& filename )
     : libfile( filename ), aunload( TRUE )
 {
     libfile.replace( '\\', '/' );
     d = new QLibraryPrivate( this );
 }
 
 /*!
     Deletes the QLibrary object.
 
     The library will be unloaded if autoUnload() is TRUE (the
     default), otherwise it stays in memory until the application
     exits.
 
     \sa unload(), setAutoUnload()
 */
 QLibrary::~QLibrary()
 {
     if ( autoUnload() )
 	unload();
 
     delete d;
 }
 
 /*!
     Returns the address of the exported symbol \a symb. The library is
     loaded if necessary. The function returns 0 if the symbol could
     not be resolved or the library could not be loaded.
 
     \code
     typedef int (*avgProc)( int, int );
 
     avgProc avg = (avgProc) library->resolve( "avg" );
     if ( avg )
 	return avg( 5, 8 );
     else
 	return -1;
     \endcode
 
 */
 void *QLibrary::resolve( const char* symb )
 {
     if ( !d->pHnd )
 	load();
     if ( !d->pHnd )
 	return 0;
 
     void *address = d->resolveSymbol( symb );
 
     return address;
 }
 
 /*!
     \overload
 
     Loads the library \a filename and returns the address of the
     exported symbol \a symb. Note that like the constructor, \a
     filename does not need to include the (platform specific) file
     extension. The library remains loaded until the process exits.
 
     The function returns 0 if the symbol could not be resolved or the
     library could not be loaded.
 
     This function is useful only if you want to resolve a single
     symbol, e.g. a function pointer from a specific library once:
 
     \code
     typedef void (*FunctionType)();
     static FunctionType *ptrFunction = 0;
     static bool triedResolve = FALSE;
     if ( !ptrFunction && !triedResolve )
 	ptrFunction = QLibrary::resolve( "mylib", "mysymb" );
 
     if ( ptrFunction )
 	ptrFunction();
     else
 	...
     \endcode
 
     If you want to resolve multiple symbols, use a QLibrary object and
     call the non-static version of resolve().
 
     \sa resolve()
 */
 void *QLibrary::resolve( const QString &filename, const char *symb )
 {
     QLibrary lib( filename );
     lib.setAutoUnload( FALSE );
     return lib.resolve( symb );
 }
 
 /*!
     Returns TRUE if the library is loaded; otherwise returns FALSE.
 
     \sa unload()
 */
 bool QLibrary::isLoaded() const
 {
     return d->pHnd != 0;
 }
 
 /*!
     Loads the library. Since resolve() always calls this function
     before resolving any symbols it is not necessary to call it
     explicitly. In some situations you might want the library loaded
     in advance, in which case you would use this function.
 */
 bool QLibrary::load()
 {
     return d->loadLibrary();
 }
 
 /*!
     Unloads the library and returns TRUE if the library could be
     unloaded; otherwise returns FALSE.
 
     This function is called by the destructor if autoUnload() is
     enabled.
 
     \sa resolve()
 */
 bool QLibrary::unload()
 {
     if ( !d->pHnd )
 	return TRUE;
 
 #if !defined(QT_NO_LIBRARY_UNLOAD)
     if ( !d->freeLibrary() ) {
 # if defined(QT_DEBUG_COMPONENT)
 	qWarning( "%s could not be unloaded", (const char*) QFile::encodeName(library()) );
 # endif
 	return FALSE;
     }
 
 # if defined(QT_DEBUG_COMPONENT) && QT_DEBUG_COMPONENT == 2
     qWarning( "%s has been unloaded", (const char*) QFile::encodeName(library()) );
 # endif
     d->pHnd = 0;
 #endif
     return TRUE;
 }
 
 /*!
     Returns TRUE if the library will be automatically unloaded when
     this wrapper object is destructed; otherwise returns FALSE. The
     default is TRUE.
 
     \sa setAutoUnload()
 */
 bool QLibrary::autoUnload() const
 {
     return (bool)aunload;
 }
 
 /*!
     If \a enabled is TRUE (the default), the wrapper object is set to
     automatically unload the library upon destruction. If \a enabled
     is FALSE, the wrapper object is not unloaded unless you explicitly
     call unload().
 
     \sa autoUnload()
 */
 void QLibrary::setAutoUnload( bool enabled )
 {
     aunload = enabled;
 }
 
 /*!
     Returns the filename of the shared library this QLibrary object
     handles, including the platform specific file extension.
 
     For example:
     \code
     QLibrary lib( "mylib" );
     QString str = lib.library();
     \endcode
     will set \e str to "mylib.dll" on Windows, and "libmylib.so" on Linux.
 */
 QString QLibrary::library() const
 {
     if ( libfile.isEmpty() )
 	return libfile;
 
     QString filename = libfile;
 
 #if defined(Q_WS_WIN)
     if ( filename.findRev( '.' ) <= filename.findRev( '/' ) )
 	filename += ".dll";
 #elif defined(Q_OS_MACX)
     if ( filename.find( ".dylib" ) == -1 )
 	filename += ".dylib";
 #else
-    if ( filename.find( ".so" ) == -1 ) {
+    QString filter = ".so";
+    if ( filename.find(filter) == -1 ) {
 	const int x = filename.findRev( "/" );
 	if ( x != -1 ) {
 	    QString path = filename.left( x + 1 );
 	    QString file = filename.right( filename.length() - x - 1 );
-	    filename = QString( "%1lib%2.so" ).arg( path ).arg( file );
+	    filename = QString( "%1lib%2.%3" ).arg( path ).arg( file ).arg( filter );
 	} else {
-	    filename = QString( "lib%1.so" ).arg( filename );
+	    filename = QString( "lib%1.%2" ).arg( filename ).arg( filter );
 	}
     }
 #endif
 
     return filename;
 }
 #endif //QT_NO_LIBRARY
diff --git a/qmake/tools/qlibrary_unix.cpp b/qmake/tools/qlibrary_unix.cpp
index f0fbdf6..12b9310 100644
--- a/qmake/tools/qlibrary_unix.cpp
+++ b/qmake/tools/qlibrary_unix.cpp
@@ -1,163 +1,180 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QLibraryPrivate class
 **
-** Created : 2000-01-01
+** Created : 000101
 **
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qplatformdefs.h"
 #include "private/qlibrary_p.h"
 
 #ifndef QT_NO_LIBRARY
 
 #if defined(QT_AOUT_UNDERSCORE)
 #include <string.h>
 #endif
 
 /*
   The platform dependent implementations of
   - loadLibrary
   - freeLibrary
   - resolveSymbol
 
   It's not too hard to guess what the functions do.
 */
 
-#if defined(QT_HPUX_LD) // for HP-UX < 11.x and 32 bit
+#if defined(Q_OS_MAC)
+
+bool QLibraryPrivate::loadLibrary()
+{
+    return FALSE;
+}
+
+bool QLibraryPrivate::freeLibrary()
+{
+    return FALSE;
+}
+
+void* QLibraryPrivate::resolveSymbol( const char* )
+{
+    return 0;
+}
+
+#elif defined(QT_HPUX_LD) // for HP-UX < 11.x and 32 bit
 
 bool QLibraryPrivate::loadLibrary()
 {
     if ( pHnd )
 	return TRUE;
 
     QString filename = library->library();
 
     pHnd = (void*)shl_load( filename.latin1(), BIND_DEFERRED | BIND_NONFATAL | DYNAMIC_PATH, 0 );
 #if defined(QT_DEBUG) || defined(QT_DEBUG_COMPONENT)
     if ( !pHnd )
 	qWarning( "%s: failed to load library!", filename.latin1() );
 #endif
     return pHnd != 0;
 }
 
 bool QLibraryPrivate::freeLibrary()
 {
     if ( !pHnd )
 	return TRUE;
 
     if ( shl_unload( (shl_t)pHnd ) ) {
 #if defined(QT_DEBUG) || defined(QT_DEBUG_COMPONENT)
 	QString filename = library->library();
 	qWarning( "%s: Failed to unload library!", filename.latin1() );
 #endif
 	return FALSE;
     }
     pHnd = 0;
     return TRUE;
 }
 
 void* QLibraryPrivate::resolveSymbol( const char* symbol )
 {
     if ( !pHnd )
 	return 0;
 
     void* address = 0;
     if ( shl_findsym( (shl_t*)&pHnd, symbol, TYPE_UNDEFINED, &address ) < 0 ) {
 #if defined(QT_DEBUG_COMPONENT)
 	QString filename = library->library();
 	qWarning( "%s: couldn't resolve symbol \"%s\"", filename.latin1(), symbol );
 #endif
     }
     return address;
 }
 
 #else // POSIX
 #include <dlfcn.h>
 
 bool QLibraryPrivate::loadLibrary()
 {
     if ( pHnd )
 	return TRUE;
 
     QString filename = library->library();
 
     pHnd = dlopen( filename.latin1(), RTLD_LAZY );
 #if defined(QT_DEBUG) || defined(QT_DEBUG_COMPONENT)
     if ( !pHnd )
 	qWarning( "%s", dlerror() );
 #endif
     return pHnd != 0;
 }
 
 bool QLibraryPrivate::freeLibrary()
 {
     if ( !pHnd )
 	return TRUE;
 
     if ( dlclose( pHnd ) ) {
 #if defined(QT_DEBUG) || defined(QT_DEBUG_COMPONENT)
 	qWarning( "%s", dlerror() );
 #endif
 	return FALSE;
     }
 
     pHnd = 0;
     return TRUE;
 }
 
 void* QLibraryPrivate::resolveSymbol( const char* symbol )
 {
     if ( !pHnd )
 	return 0;
 
 #if defined(QT_AOUT_UNDERSCORE)
     // older a.out systems add an underscore in front of symbols
     char* undrscr_symbol = new char[strlen(symbol)+2];
     undrscr_symbol[0] = '_';
     strcpy(undrscr_symbol+1, symbol);
     void* address = dlsym( pHnd, undrscr_symbol );
     delete [] undrscr_symbol;
 #else
     void* address = dlsym( pHnd, symbol );
 #endif
 #if defined(QT_DEBUG_COMPONENT)
     const char* error = dlerror();
     if ( error )
 	qWarning( "%s", error );
 #endif
     return address;
 }
 
 #endif // POSIX
 
 #endif
diff --git a/qmake/tools/qmutex_unix.cpp b/qmake/tools/qmutex_unix.cpp
index c861b2d..3eb59cf 100644
--- a/qmake/tools/qmutex_unix.cpp
+++ b/qmake/tools/qmutex_unix.cpp
@@ -1,687 +1,689 @@
 /****************************************************************************
 ** $Id$
 **
 ** QMutex class for Unix
 **
 ** Created : 20010725
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #if defined(QT_THREAD_SUPPORT)
 
 #include "qplatformdefs.h"
 
 typedef pthread_mutex_t     Q_MUTEX_T;
 
 // POSIX threads mutex types
 #if ((defined(PTHREAD_MUTEX_RECURSIVE) && defined(PTHREAD_MUTEX_DEFAULT)) || \
-     defined(Q_OS_FREEBSD)) && !defined(Q_OS_UNIXWARE) && !defined(Q_OS_SOLARIS)
-    // POSIX 1003.1c-1995 - We love this OS
+     defined(Q_OS_FREEBSD)) && !defined(Q_OS_UNIXWARE) && !defined(Q_OS_SOLARIS) && \
+    !defined(Q_OS_MAC)
+// POSIX 1003.1c-1995 - We love this OS
 #  define Q_MUTEX_SET_TYPE(a, b) pthread_mutexattr_settype((a), (b))
 #  if defined(QT_CHECK_RANGE)
 #    define Q_NORMAL_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK
 #  else
 #    define Q_NORMAL_MUTEX_TYPE PTHREAD_MUTEX_DEFAULT
 #  endif
 #  define Q_RECURSIVE_MUTEX_TYPE PTHREAD_MUTEX_RECURSIVE
 #elif defined(MUTEX_NONRECURSIVE_NP) && defined(MUTEX_RECURSIVE_NP)
 // POSIX 1003.4a pthreads draft extensions
 #  define Q_MUTEX_SET_TYPE(a, b) pthread_mutexattr_setkind_np((a), (b));
 #  define Q_NORMAL_MUTEX_TYPE MUTEX_NONRECURSIVE_NP
 #  define Q_RECURSIVE_MUTEX_TYPE MUTEX_RECURSIVE_NP
 #else
 // Unknown mutex types - skip them
 #  define Q_MUTEX_SET_TYPE(a, b)
 #  undef  Q_NORMAL_MUTEX_TYPE
 #  undef  Q_RECURSIVE_MUTEX_TYPE
 #endif
 
 #include "qmutex.h"
 #include "qmutex_p.h"
 
 #include <errno.h>
 #include <string.h>
 
 
 // Private class declarations
 
 class QRealMutexPrivate : public QMutexPrivate {
 public:
     QRealMutexPrivate(bool = FALSE);
 
     void lock();
     void unlock();
     bool locked();
     bool trylock();
     int type() const;
 
     bool recursive;
 };
 
 #ifndef    Q_RECURSIVE_MUTEX_TYPE
 class QRecursiveMutexPrivate : public QMutexPrivate
 {
 public:
     QRecursiveMutexPrivate();
     ~QRecursiveMutexPrivate();
 
     void lock();
     void unlock();
     bool locked();
     bool trylock();
     int type() const;
 
     int count;
     unsigned long owner;
     pthread_mutex_t handle2;
 };
 #endif // !Q_RECURSIVE_MUTEX_TYPE
 
 
 // Private class implementation
 
 // base destructor
 QMutexPrivate::~QMutexPrivate()
 {
     int ret = pthread_mutex_destroy(&handle);
 
 #ifdef QT_CHECK_RANGE
     if ( ret )
 	qWarning( "Mutex destroy failure: %s", strerror( ret ) );
 #endif
 }
 
 // real mutex class
 QRealMutexPrivate::QRealMutexPrivate(bool recurs)
     : recursive(recurs)
 {
     pthread_mutexattr_t attr;
     pthread_mutexattr_init(&attr);
     Q_MUTEX_SET_TYPE(&attr, recursive ? Q_RECURSIVE_MUTEX_TYPE : Q_NORMAL_MUTEX_TYPE);
     Q_UNUSED(recursive);
     int ret = pthread_mutex_init(&handle, &attr);
     pthread_mutexattr_destroy(&attr);
 
 #ifdef QT_CHECK_RANGE
     if( ret )
 	qWarning( "Mutex init failure: %s", strerror( ret ) );
 #endif // QT_CHECK_RANGE
 }
 
 void QRealMutexPrivate::lock()
 {
     int ret = pthread_mutex_lock(&handle);
 
 #ifdef QT_CHECK_RANGE
     if (ret)
 	qWarning("Mutex lock failure: %s", strerror(ret));
 #endif
 }
 
 void QRealMutexPrivate::unlock()
 {
     int ret = pthread_mutex_unlock(&handle);
 
 #ifdef QT_CHECK_RANGE
     if (ret)
 	qWarning("Mutex unlock failure: %s", strerror(ret));
 #endif
 }
 
 bool QRealMutexPrivate::locked()
 {
     int ret = pthread_mutex_trylock(&handle);
 
     if (ret == EBUSY) {
 	return TRUE;
     } else if (ret) {
 #ifdef QT_CHECK_RANGE
 	qWarning("Mutex locktest failure: %s", strerror(ret));
 #endif
     } else
 	pthread_mutex_unlock(&handle);
 
     return FALSE;
 }
 
 bool QRealMutexPrivate::trylock()
 {
     int ret = pthread_mutex_trylock(&handle);
 
     if (ret == EBUSY) {
 	return FALSE;
     } else if (ret) {
 #ifdef QT_CHECK_RANGE
 	qWarning("Mutex trylock failure: %s", strerror(ret));
 #endif
 	return FALSE;
     }
 
     return TRUE;
 }
 
 int QRealMutexPrivate::type() const
 {
     return recursive ? Q_MUTEX_RECURSIVE : Q_MUTEX_NORMAL;
 }
 
 
 #ifndef    Q_RECURSIVE_MUTEX_TYPE
 QRecursiveMutexPrivate::QRecursiveMutexPrivate()
     : count(0), owner(0)
 {
     pthread_mutexattr_t attr;
     pthread_mutexattr_init(&attr);
     Q_MUTEX_SET_TYPE(&attr, Q_NORMAL_MUTEX_TYPE);
     int ret = pthread_mutex_init(&handle, &attr);
     pthread_mutexattr_destroy(&attr);
 
 #  ifdef QT_CHECK_RANGE
     if (ret)
 	qWarning( "Mutex init failure: %s", strerror(ret) );
 #  endif
 
     pthread_mutexattr_init(&attr);
     ret = pthread_mutex_init( &handle2, &attr );
     pthread_mutexattr_destroy(&attr);
 
 #  ifdef QT_CHECK_RANGE
     if (ret)
 	qWarning( "Mutex init failure: %s", strerror(ret) );
 #  endif
 }
 
 QRecursiveMutexPrivate::~QRecursiveMutexPrivate()
 {
     int ret = pthread_mutex_destroy(&handle2);
 
 #  ifdef QT_CHECK_RANGE
     if (ret)
 	qWarning( "Mutex destroy failure: %s", strerror(ret) );
 #  endif
 }
 
 void QRecursiveMutexPrivate::lock()
 {
     pthread_mutex_lock(&handle2);
 
     if (count > 0 && owner == (unsigned long) pthread_self()) {
 	count++;
     } else {
 	pthread_mutex_unlock(&handle2);
 	pthread_mutex_lock(&handle);
 	pthread_mutex_lock(&handle2);
 	count = 1;
 	owner = (unsigned long) pthread_self();
     }
 
     pthread_mutex_unlock(&handle2);
 }
 
 void QRecursiveMutexPrivate::unlock()
 {
     pthread_mutex_lock(&handle2);
 
     if (owner == (unsigned long) pthread_self()) {
 	// do nothing if the count is already 0... to reflect the behaviour described
 	// in the docs
 	if (count && (--count) < 1) {
 	    count = 0;
 	    pthread_mutex_unlock(&handle);
 	}
     } else {
 #ifdef QT_CHECK_RANGE
 	qWarning("QMutex::unlock: unlock from different thread than locker");
 	qWarning("                was locked by %d, unlock attempt from %d",
 		 (int)owner, (int)pthread_self());
 #endif
     }
 
     pthread_mutex_unlock(&handle2);
 }
 
 bool QRecursiveMutexPrivate::locked()
 {
     pthread_mutex_lock(&handle2);
 
     bool ret;
     int code = pthread_mutex_trylock(&handle);
 
     if (code == EBUSY) {
 	ret = TRUE;
     } else {
 #ifdef QT_CHECK_RANGE
 	if (code)
 	    qWarning("Mutex trylock failure: %s", strerror(code));
 #endif
 
 	pthread_mutex_unlock(&handle);
 	ret = FALSE;
     }
 
     pthread_mutex_unlock(&handle2);
 
     return ret;
 }
 
 bool QRecursiveMutexPrivate::trylock()
 {
     bool ret = TRUE;
 
     pthread_mutex_lock(&handle2);
 
     if ( count > 0 && owner == (unsigned long) pthread_self() ) {
 	count++;
     } else {
         int code = pthread_mutex_trylock(&handle);
 
 	if (code == EBUSY) {
 	    ret = FALSE;
 	} else if (code) {
 #ifdef QT_CHECK_RANGE
 	    qWarning("Mutex trylock failure: %s", strerror(code));
 #endif
 	    ret = FALSE;
 	} else {
 	    count = 1;
 	    owner = (unsigned long) pthread_self();
 	}
     }
 
     pthread_mutex_unlock(&handle2);
 
     return ret;
 }
 
 int QRecursiveMutexPrivate::type() const
 {
     return Q_MUTEX_RECURSIVE;
 }
 
 #endif // !Q_RECURSIVE_MUTEX_TYPE
 
 
 /*!
     \class QMutex qmutex.h
     \threadsafe
     \brief The QMutex class provides access serialization between threads.
 
     \ingroup thread
     \ingroup environment
 
     The purpose of a QMutex is to protect an object, data structure or
     section of code so that only one thread can access it at a time
     (This is similar to the Java \c synchronized keyword). For
     example, say there is a method which prints a message to the user
     on two lines:
 
     \code
     int number = 6;
 
     void method1()
     {
         number *= 5;
 	number /= 4;
     }
 
     void method1()
     {
         number *= 3;
 	number /= 2;
     }
     \endcode
 
     If these two methods are called in succession, the following happens:
 
     \code
     // method1()
     number *= 5;	// number is now 30
     number /= 4;	// number is now 7
 
     // method2()
     number *= 3;	// nubmer is now 21
     number /= 2;	// number is now 10
     \endcode
 
     If these two methods are called simultaneously from two threads then the
     following sequence could result:
 
     \code
     // Thread 1 calls method1()
     number *= 5;	// number is now 30
 
     // Thread 2 calls method2().
     //
     // Most likely Thread 1 has been put to sleep by the operating
     // system to allow Thread 2 to run.
     number *= 3;	// number is now 90
     number /= 2;	// number is now 45
 
     // Thread 1 finishes executing.
     number /= 4;	// number is now 11, instead of 10
     \endcode
 
     If we add a mutex, we should get the result we want:
 
     \code
     QMutex mutex;
     int number = 6;
 
     void method1()
     {
 	mutex.lock();
         number *= 5;
 	number /= 4;
 	mutex.unlock();
     }
 
     void method2()
     {
 	mutex.lock();
         number *= 3;
 	number /= 2;
 	mutex.unlock();
     }
     \endcode
 
     Then only one thread can modify \c number at any given time and
     the result is correct. This is a trivial example, of course, but
     applies to any other case where things need to happen in a
     particular sequence.
 
     When you call lock() in a thread, other threads that try to call
     lock() in the same place will block until the thread that got the
     lock calls unlock(). A non-blocking alternative to lock() is
     tryLock().
 */
 
 /*!
     Constructs a new mutex. The mutex is created in an unlocked state.
     A recursive mutex is created if \a recursive is TRUE; a normal
     mutex is created if \a recursive is FALSE (the default). With a
     recursive mutex, a thread can lock the same mutex multiple times
     and it will not be unlocked until a corresponding number of
     unlock() calls have been made.
 */
 QMutex::QMutex(bool recursive)
 {
 #ifndef    Q_RECURSIVE_MUTEX_TYPE
     if ( recursive )
 	d = new QRecursiveMutexPrivate();
     else
 #endif // !Q_RECURSIVE_MUTEX_TYPE
 	d = new QRealMutexPrivate(recursive);
 }
 
 /*!
     Destroys the mutex.
 
     \warning If you destroy a mutex that still holds a lock the
     resultant behavior is undefined.
 */
 QMutex::~QMutex()
 {
     delete d;
 }
 
 /*!
     Attempt to lock the mutex. If another thread has locked the mutex
     then this call will \e block until that thread has unlocked it.
 
     \sa unlock(), locked()
 */
 void QMutex::lock()
 {
     d->lock();
 }
 
 /*!
     Unlocks the mutex. Attempting to unlock a mutex in a different
     thread to the one that locked it results in an error. Unlocking a
     mutex that is not locked results in undefined behaviour (varies
     between different Operating Systems' thread implementations).
 
     \sa lock(), locked()
 */
 void QMutex::unlock()
 {
     d->unlock();
 }
 
 /*!
     Returns TRUE if the mutex is locked by another thread; otherwise
     returns FALSE.
 
     \warning Due to differing implementations of recursive mutexes on
     various platforms, calling this function from the same thread that
     previously locked the mutex will return undefined results.
 
     \sa lock(), unlock()
 */
 bool QMutex::locked()
 {
     return d->locked();
 }
 
 /*!
     Attempt to lock the mutex. If the lock was obtained, this function
     returns TRUE. If another thread has locked the mutex, this
     function returns FALSE, instead of waiting for the mutex to become
     available, i.e. it does not block.
 
     If the lock was obtained, the mutex must be unlocked with unlock()
     before another thread can successfully lock it.
 
     \sa lock(), unlock(), locked()
 */
 bool QMutex::tryLock()
 {
     return d->trylock();
 }
 
 /*!
     \class QMutexLocker qmutex.h
     \brief The QMutexLocker class simplifies locking and unlocking QMutexes.
 
     \threadsafe
 
     \ingroup thread
     \ingroup environment
 
     The purpose of QMutexLocker is to simplify QMutex locking and
     unlocking. Locking and unlocking a QMutex in complex functions and
     statements or in exception handling code is error prone and
     difficult to debug. QMutexLocker should be used in such situations
     to ensure that the state of the mutex is well defined and always
     locked and unlocked properly.
 
     QMutexLocker should be created within a function where a QMutex
     needs to be locked. The mutex is locked when QMutexLocker is
     created, and unlocked when QMutexLocker is destroyed.
 
     For example, this complex function locks a QMutex upon entering
     the function and unlocks the mutex at all the exit points:
 
     \code
     int complexFunction( int flag )
     {
 	mutex.lock();
 
 	int return_value = 0;
 
 	switch ( flag ) {
 	case 0:
 	case 1:
 	    {
 		mutex.unlock();
 		return moreComplexFunction( flag );
 	    }
 
 	case 2:
 	    {
 		int status = anotherFunction();
 		if ( status < 0 ) {
 		    mutex.unlock();
 		    return -2;
 		}
 		return_value = status + flag;
 		break;
 	    }
 
 	default:
 	    {
 		if ( flag > 10 ) {
 		    mutex.unlock();
 		    return -1;
 		}
 		break;
 	    }
 	}
 
 	mutex.unlock();
 	return return_value;
     }
     \endcode
 
     This example function will get more complicated as it is
     developed, which increases the likelihood that errors will occur.
 
     Using QMutexLocker greatly simplifies the code, and makes it more
     readable:
 
     \code
     int complexFunction( int flag )
     {
 	QMutexLocker locker( &mutex );
 
 	int return_value = 0;
 
 	switch ( flag ) {
 	case 0:
 	case 1:
 	    {
 		return moreComplexFunction( flag );
 	    }
 
 	case 2:
 	    {
 		int status = anotherFunction();
 		if ( status < 0 )
 		    return -2;
 		return_value = status + flag;
 		break;
 	    }
 
 	default:
 	    {
 		if ( flag > 10 )
 		    return -1;
 		break;
 	    }
 	}
 
 	return return_value;
     }
     \endcode
 
     Now, the mutex will always be unlocked when the QMutexLocker
     object is destroyed (when the function returns since \c locker is
     an auto variable).
 
     The same principle applies to code that throws and catches
     exceptions. An exception that is not caught in the function that
     has locked the mutex has no way of unlocking the mutex before the
     exception is passed up the stack to the calling function.
 
     QMutexLocker also provides a mutex() member function that returns
     the mutex on which the QMutexLocker is operating. This is useful
     for code that needs access to the mutex, such as
     QWaitCondition::wait(). For example:
 
     \code
     class SignalWaiter
     {
     private:
 	QMutexLocker locker;
 
     public:
 	SignalWaiter( QMutex *mutex )
 	    : locker( mutex )
 	{
 	}
 
 	void waitForSignal()
 	{
 	    ...
 	    ...
 	    ...
 
 	    while ( ! signalled )
 		waitcondition.wait( locker.mutex() );
 
 	    ...
 	    ...
 	    ...
 	}
     };
     \endcode
 
     \sa QMutex, QWaitCondition
 */
 
 /*!
     \fn QMutexLocker::QMutexLocker( QMutex *mutex )
 
     Constructs a QMutexLocker and locks \a mutex. The mutex will be
-    unlocked when the QMutexLocker is destroyed.
+    unlocked when the QMutexLocker is destroyed. If \a mutex is zero,
+    QMutexLocker does nothing.
 
     \sa QMutex::lock()
 */
 
 /*!
     \fn QMutexLocker::~QMutexLocker()
 
     Destroys the QMutexLocker and unlocks the mutex which was locked
     in the constructor.
 
     \sa QMutexLocker::QMutexLocker(), QMutex::unlock()
 */
 
 /*!
     \fn QMutex *QMutexLocker::mutex() const
 
     Returns a pointer to the mutex which was locked in the
     constructor.
 
     \sa QMutexLocker::QMutexLocker()
 */
 
 #endif // QT_THREAD_SUPPORT
diff --git a/qmake/tools/qmutexpool.cpp b/qmake/tools/qmutexpool.cpp
index 9ed2829..a8e7402 100644
--- a/qmake/tools/qmutexpool.cpp
+++ b/qmake/tools/qmutexpool.cpp
@@ -1,130 +1,152 @@
+/****************************************************************************
+** $Id$
+**
+** ...
+**
+** Copyright (C) 2002 Trolltech AS.  All rights reserved.
+**
+** This file is part of the tools module of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
+** licenses may use this file in accordance with the Qt Commercial License
+** Agreement provided with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
 #include "qmutexpool_p.h"
 
 #ifdef QT_THREAD_SUPPORT
 
 #include <qthread.h>
-#include <stdio.h>
 
 QMutexPool *qt_global_mutexpool = 0;
 
-// this is an internal class used only for inititalizing the global mutexpool
-class QGlobalMutexPoolInitializer
-{
-public:
-    inline QGlobalMutexPoolInitializer()
-    {
-	/*
-	  Purify will report a leak here. However, this mutex pool must be alive
-	  until *everything* in Qt has been destructed. Unfortunately there is
-	  no way to guarantee this, so we never destroy this mutex pool.
-	*/
-	qt_global_mutexpool = new QMutexPool( TRUE );
-    }
-};
-QGlobalMutexPoolInitializer qt_global_mutexpool_initializer;
 
 /*!
     \class QMutexPool qmutexpool_p.h
     \brief The QMutexPool class provides a pool of QMutex objects.
 
     \internal
 
     \ingroup thread
 
     QMutexPool is a convenience class that provides access to a fixed
     number of QMutex objects.
 
     Typical use of a QMutexPool is in situations where it is not
     possible or feasible to use one QMutex for every protected object.
     The mutex pool will return a mutex based on the address of the
     object that needs protection.
 
     For example, consider this simple class:
 
     \code
     class Number {
     public:
 	Number( double n ) : num ( n ) { }
 
 	void setNumber( double n ) { num = n; }
 	double number() const { return num; }
 
     private:
 	double num;
     };
     \endcode
 
     Adding a QMutex member to the Number class does not make sense,
     because it is so small. However, in order to ensure that access to
     each Number is protected, you need to use a mutex. In this case, a
     QMutexPool would be ideal.
 
     Code to calculate the square of a number would then look something
     like this:
 
     \code
     void calcSquare( Number *num )
     {
 	QMutexLocker locker( mutexpool.get( num ) );
 	num.setNumber( num.number() * num.number() );
     }
     \endcode
 
     This function will safely calculate the square of a number, since
     it uses a mutex from a QMutexPool. The mutex is locked and
     unlocked automatically by the QMutexLocker class. See the
     QMutexLocker documentation for more details.
 */
 
 /*!
     Constructs  a QMutexPool, reserving space for \a size QMutexes. If
     \a recursive is TRUE, all QMutexes in the pool will be recursive
     mutexes; otherwise they will all be non-recursive (the default).
 
     The QMutexes are created when needed, and deleted when the
     QMutexPool is destructed.
 */
 QMutexPool::QMutexPool( bool recursive, int size )
-    : mutex( FALSE ), mutexes( size ), recurs( recursive )
+    : mutex( FALSE ), count( size ), recurs( recursive )
 {
-    mutexes.fill( 0 );
+    mutexes = new QMutex*[count];
+    for ( int index = 0; index < count; ++index ) {
+	mutexes[index] = 0;
+    }
 }
 
 /*!
     Destructs a QMutexPool. All QMutexes that were created by the pool
     are deleted.
 */
 QMutexPool::~QMutexPool()
 {
     QMutexLocker locker( &mutex );
-    QMutex **d = mutexes.data();
-    for ( int index = 0; (uint) index < mutexes.size(); index++ ) {
-	delete d[index];
-	d[index] = 0;
+    for ( int index = 0; index < count; ++index ) {
+	delete mutexes[index];
+	mutexes[index] = 0;
     }
+    delete [] mutexes;
+    mutexes = 0;
 }
 
 /*!
     Returns a QMutex from the pool. QMutexPool uses the value \a
     address to determine which mutex is retured from the pool.
 */
 QMutex *QMutexPool::get( void *address )
 {
-    QMutex **d = mutexes.data();
-    int index = (int)( (ulong) address % mutexes.size() );
+    int index = (int) ( (unsigned long) address % count );
 
-    if ( ! d[index] ) {
+    if ( ! mutexes[index] ) {
 	// mutex not created, create one
 
 	QMutexLocker locker( &mutex );
 	// we need to check once again that the mutex hasn't been created, since
 	// 2 threads could be trying to create a mutex as the same index...
-	if ( ! d[index] ) {
-	    d[index] = new QMutex( recurs );
+	if ( ! mutexes[index] ) {
+	    mutexes[index] = new QMutex( recurs );
 	}
     }
 
-    return d[index];
+    return mutexes[index];
 }
 
 #endif
diff --git a/qmake/tools/qregexp.cpp b/qmake/tools/qregexp.cpp
index 500efed..0c1f060 100644
--- a/qmake/tools/qregexp.cpp
+++ b/qmake/tools/qregexp.cpp
@@ -1,3935 +1,3943 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QRegExp class
 **
 ** Created : 950126
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qregexp.h"
 
 #ifndef QT_NO_REGEXP
 
 #include "qmemarray.h"
 #include "qbitarray.h"
 #include "qcache.h"
 #include "qcleanuphandler.h"
 #include "qintdict.h"
 #include "qmap.h"
 #include "qptrvector.h"
 #include "qstring.h"
 #include "qtl.h"
 
 #ifdef QT_THREAD_SUPPORT
 #include "qmutexpool_p.h"
 #endif // QT_THREAD_SUPPORT
 
 #undef QT_TRANSLATE_NOOP
 #define QT_TRANSLATE_NOOP( context, sourceText ) sourceText
 
 #include <limits.h>
 
 // error strings for the regexp parser
 #define RXERR_OK         QT_TRANSLATE_NOOP( "QRegExp", "no error occurred" )
 #define RXERR_DISABLED   QT_TRANSLATE_NOOP( "QRegExp", "disabled feature used" )
 #define RXERR_CHARCLASS  QT_TRANSLATE_NOOP( "QRegExp", "bad char class syntax" )
 #define RXERR_LOOKAHEAD  QT_TRANSLATE_NOOP( "QRegExp", "bad lookahead syntax" )
 #define RXERR_REPETITION QT_TRANSLATE_NOOP( "QRegExp", "bad repetition syntax" )
 #define RXERR_OCTAL      QT_TRANSLATE_NOOP( "QRegExp", "invalid octal value" )
 #define RXERR_LEFTDELIM  QT_TRANSLATE_NOOP( "QRegExp", "missing left delim" )
 #define RXERR_END        QT_TRANSLATE_NOOP( "QRegExp", "unexpected end" )
 #define RXERR_LIMIT      QT_TRANSLATE_NOOP( "QRegExp", "met internal limit" )
 
 /*
   WARNING! Be sure to read qregexp.tex before modifying this file.
 */
 
 /*!
     \class QRegExp qregexp.h
     \reentrant
     \brief The QRegExp class provides pattern matching using regular expressions.
 
     \ingroup tools
     \ingroup misc
     \ingroup shared
     \mainclass
     \keyword regular expression
 
     Regular expressions, or "regexps", provide a way to find patterns
     within text. This is useful in many contexts, for example:
 
     \table
     \row \i Validation
 	 \i A regexp can be used to check whether a piece of text
 	 meets some criteria, e.g. is an integer or contains no
 	 whitespace.
     \row \i Searching
 	 \i Regexps provide a much more powerful means of searching
 	 text than simple string matching does. For example we can
 	 create a regexp which says "find one of the words 'mail',
 	 'letter' or 'correspondence' but not any of the words
 	 'email', 'mailman' 'mailer', 'letterbox' etc."
     \row \i Search and Replace
 	 \i A regexp can be used to replace a pattern with a piece of
 	 text, for example replace all occurrences of '&' with
 	 '\&amp;' except where the '&' is already followed by 'amp;'.
     \row \i String Splitting
 	 \i A regexp can be used to identify where a string should be
 	 split into its component fields, e.g. splitting tab-delimited
 	 strings.
     \endtable
 
     We present a very brief introduction to regexps, a description of
     Qt's regexp language, some code examples, and finally the function
     documentation itself. QRegExp is modeled on Perl's regexp
     language, and also fully supports Unicode. QRegExp can also be
     used in the weaker 'wildcard' (globbing) mode which works in a
     similar way to command shells. A good text on regexps is \e
     {Mastering Regular Expressions: Powerful Techniques for Perl and
     Other Tools} by Jeffrey E. Friedl, ISBN 1565922573.
 
     Experienced regexp users may prefer to skip the introduction and
     go directly to the relevant information.
 
     \tableofcontents
 
     \section1 Introduction
 
     Regexps are built up from expressions, quantifiers, and assertions.
     The simplest form of expression is simply a character, e.g.
     <b>x</b> or <b>5</b>. An expression can also be a set of
     characters. For example, <b>[ABCD]</b>, will match an <b>A</b> or
     a <b>B</b> or a <b>C</b> or a <b>D</b>. As a shorthand we could
     write this as <b>[A-D]</b>. If we want to match any of the
     captital letters in the English alphabet we can write
     <b>[A-Z]</b>. A quantifier tells the regexp engine how many
     occurrences of the expression we want, e.g. <b>x{1,1}</b> means
     match an <b>x</b> which occurs at least once and at most once.
     We'll look at assertions and more complex expressions later.
 
     Note that in general regexps cannot be used to check for balanced
     brackets or tags. For example if you want to match an opening html
     \c <b> and its closing \c </b> you can only use a regexp if you
     know that these tags are not nested; the html fragment, \c{<b>bold
     <b>bolder</b></b>} will not match as expected. If you know the
     maximum level of nesting it is possible to create a regexp that
     will match correctly, but for an unknown level of nesting, regexps
     will fail.
 
     We'll start by writing a regexp to match integers in the range 0
     to 99. We will require at least one digit so we will start with
     <b>[0-9]{1,1}</b> which means match a digit exactly once. This
     regexp alone will match integers in the range 0 to 9. To match one
     or two digits we can increase the maximum number of occurrences so
     the regexp becomes <b>[0-9]{1,2}</b> meaning match a digit at
     least once and at most twice. However, this regexp as it stands
     will not match correctly. This regexp will match one or two digits
     \e within a string. To ensure that we match against the whole
     string we must use the anchor assertions. We need <b>^</b> (caret)
     which when it is the first character in the regexp means that the
     regexp must match from the beginning of the string. And we also
     need <b>$</b> (dollar) which when it is the last character in the
     regexp means that the regexp must match until the end of the
     string. So now our regexp is <b>^[0-9]{1,2}$</b>. Note that
     assertions, such as <b>^</b> and <b>$</b>, do not match any
     characters.
 
     If you've seen regexps elsewhere they may have looked different from
     the ones above. This is because some sets of characters and some
     quantifiers are so common that they have special symbols to
     represent them. <b>[0-9]</b> can be replaced with the symbol
     <b>\d</b>. The quantifier to match exactly one occurrence,
     <b>{1,1}</b>, can be replaced with the expression itself. This means
     that <b>x{1,1}</b> is exactly the same as <b>x</b> alone. So our 0
     to 99 matcher could be written <b>^\d{1,2}$</b>. Another way of
     writing it would be <b>^\d\d{0,1}$</b>, i.e. from the start of the
     string match a digit followed by zero or one digits. In practice
     most people would write it <b>^\d\d?$</b>. The <b>?</b> is a
     shorthand for the quantifier <b>{0,1}</b>, i.e. a minimum of no
     occurrences a maximum of one occurrence. This is used to make an
     expression optional. The regexp <b>^\d\d?$</b> means "from the
     beginning of the string match one digit followed by zero or one
     digits and then the end of the string".
 
     Our second example is matching the words 'mail', 'letter' or
     'correspondence' but without matching 'email', 'mailman',
     'mailer', 'letterbox' etc. We'll start by just matching 'mail'. In
     full the regexp is, <b>m{1,1}a{1,1}i{1,1}l{1,1}</b>, but since
     each expression itself is automatically quantified by <b>{1,1}</b>
     we can simply write this as <b>mail</b>; an 'm' followed by an 'a'
     followed by an 'i' followed by an 'l'. The symbol '|' (bar) is
     used for \e alternation, so our regexp now becomes
     <b>mail|letter|correspondence</b> which means match 'mail' \e or
     'letter' \e or 'correspondence'. Whilst this regexp will find the
     words we want it will also find words we don't want such as
     'email'. We will start by putting our regexp in parentheses,
     <b>(mail|letter|correspondence)</b>. Parentheses have two effects,
     firstly they group expressions together and secondly they identify
     parts of the regexp that we wish to \link #capturing-text capture
     \endlink. Our regexp still matches any of the three words but now
     they are grouped together as a unit. This is useful for building
     up more complex regexps. It is also useful because it allows us to
     examine which of the words actually matched. We need to use
     another assertion, this time <b>\b</b> "word boundary":
     <b>\b(mail|letter|correspondence)\b</b>. This regexp means "match
     a word boundary followed by the expression in parentheses followed
     by another word boundary". The <b>\b</b> assertion matches at a \e
     position in the regexp not a \e character in the regexp. A word
     boundary is any non-word character such as a space a newline or
     the beginning or end of the string.
 
     For our third example we want to replace ampersands with the HTML
     entity '\&amp;'. The regexp to match is simple: <b>\&</b>, i.e.
     match one ampersand. Unfortunately this will mess up our text if
     some of the ampersands have already been turned into HTML
     entities. So what we really want to say is replace an ampersand
     providing it is not followed by 'amp;'. For this we need the
     negative lookahead assertion and our regexp becomes:
     <b>\&(?!amp;)</b>. The negative lookahead assertion is introduced
     with '(?!' and finishes at the ')'. It means that the text it
     contains, 'amp;' in our example, must \e not follow the expression
     that preceeds it.
 
     Regexps provide a rich language that can be used in a variety of
     ways. For example suppose we want to count all the occurrences of
     'Eric' and 'Eirik' in a string. Two valid regexps to match these
     are <b>\\b(Eric|Eirik)\\b</b> and <b>\\bEi?ri[ck]\\b</b>. We need
     the word boundary '\b' so we don't get 'Ericsson' etc. The second
     regexp actually matches more than we want, 'Eric', 'Erik', 'Eiric'
     and 'Eirik'.
 
     We will implement some the examples above in the
     \link #code-examples code examples \endlink section.
 
     \target characters-and-abbreviations-for-sets-of-characters
     \section1 Characters and Abbreviations for Sets of Characters
 
     \table
     \header \i Element \i Meaning
     \row \i <b>c</b>
 	 \i Any character represents itself unless it has a special
 	 regexp meaning. Thus <b>c</b> matches the character \e c.
     \row \i <b>\\c</b>
 	 \i A character that follows a backslash matches the character
 	 itself except where mentioned below. For example if you
 	 wished to match a literal caret at the beginning of a string
 	 you would write <b>\^</b>.
     \row \i <b>\\a</b>
 	 \i This matches the ASCII bell character (BEL, 0x07).
     \row \i <b>\\f</b>
 	 \i This matches the ASCII form feed character (FF, 0x0C).
     \row \i <b>\\n</b>
 	 \i This matches the ASCII line feed character (LF, 0x0A, Unix newline).
     \row \i <b>\\r</b>
 	 \i This matches the ASCII carriage return character (CR, 0x0D).
     \row \i <b>\\t</b>
 	 \i This matches the ASCII horizontal tab character (HT, 0x09).
     \row \i <b>\\v</b>
 	 \i This matches the ASCII vertical tab character (VT, 0x0B).
     \row \i <b>\\xhhhh</b>
 	 \i This matches the Unicode character corresponding to the
 	 hexadecimal number hhhh (between 0x0000 and 0xFFFF). \0ooo
 	 (i.e., \zero ooo) matches the ASCII/Latin-1 character
 	 corresponding to the octal number ooo (between 0 and 0377).
     \row \i <b>. (dot)</b>
 	 \i This matches any character (including newline).
     \row \i <b>\\d</b>
-	 \i This matches a digit (see QChar::isDigit()).
+	 \i This matches a digit (QChar::isDigit()).
     \row \i <b>\\D</b>
 	 \i This matches a non-digit.
     \row \i <b>\\s</b>
-	 \i This matches a whitespace (see QChar::isSpace()).
+	 \i This matches a whitespace (QChar::isSpace()).
     \row \i <b>\\S</b>
 	 \i This matches a non-whitespace.
     \row \i <b>\\w</b>
-	 \i This matches a word character (see QChar::isLetterOrNumber()).
+	 \i This matches a word character (QChar::isLetterOrNumber() or '_').
     \row \i <b>\\W</b>
 	 \i This matches a non-word character.
     \row \i <b>\\n</b>
 	 \i The n-th \link #capturing-text backreference \endlink,
 	 e.g. \1, \2, etc.
     \endtable
 
     \e {Note that the C++ compiler transforms backslashes in strings
     so to include a <b>\\</b> in a regexp you will need to enter it
     twice, i.e. <b>\\\\</b>.}
 
     \target sets-of-characters
     \section1 Sets of Characters
 
     Square brackets are used to match any character in the set of
     characters contained within the square brackets. All the character
     set abbreviations described above can be used within square
     brackets. Apart from the character set abbreviations and the
     following two exceptions no characters have special meanings in
     square brackets.
 
     \table
     \row \i <b>^</b>
 	 \i The caret negates the character set if it occurs as the
 	 first character, i.e. immediately after the opening square
 	 bracket. For example, <b>[abc]</b> matches 'a' or 'b' or 'c',
 	 but <b>[^abc]</b> matches anything \e except 'a' or 'b' or
 	 'c'.
     \row \i <b>-</b>
 	 \i The dash is used to indicate a range of characters, for
 	 example <b>[W-Z]</b> matches 'W' or 'X' or 'Y' or 'Z'.
     \endtable
 
     Using the predefined character set abbreviations is more portable
     than using character ranges across platforms and languages. For
     example, <b>[0-9]</b> matches a digit in Western alphabets but
     <b>\d</b> matches a digit in \e any alphabet.
 
     Note that in most regexp literature sets of characters are called
     "character classes".
 
     \target quantifiers
     \section1 Quantifiers
 
     By default an expression is automatically quantified by
     <b>{1,1}</b>, i.e. it should occur exactly once. In the following
     list <b>\e {E}</b> stands for any expression. An expression is a
     character or an abbreviation for a set of characters or a set of
     characters in square brackets or any parenthesised expression.
 
     \table
     \row \i <b>\e {E}?</b>
 	 \i Matches zero or one occurrence of \e E. This quantifier
 	 means "the previous expression is optional" since it will
 	 match whether or not the expression occurs in the string. It
 	 is the same as <b>\e {E}{0,1}</b>. For example <b>dents?</b>
 	 will match 'dent' and 'dents'.
 
     \row \i <b>\e {E}+</b>
 	 \i Matches one or more occurrences of \e E. This is the same
 	 as <b>\e {E}{1,MAXINT}</b>. For example, <b>0+</b> will match
 	 '0', '00', '000', etc.
 
     \row \i <b>\e {E}*</b>
 	 \i Matches zero or more occurrences of \e E. This is the same
 	 as <b>\e {E}{0,MAXINT}</b>. The <b>*</b> quantifier is often
 	 used by a mistake. Since it matches \e zero or more
 	 occurrences it will match no occurrences at all. For example
 	 if we want to match strings that end in whitespace and use
 	 the regexp <b>\s*$</b> we would get a match on every string.
 	 This is because we have said find zero or more whitespace
 	 followed by the end of string, so even strings that don't end
 	 in whitespace will match. The regexp we want in this case is
 	 <b>\s+$</b> to match strings that have at least one
 	 whitespace at the end.
 
     \row \i <b>\e {E}{n}</b>
 	 \i Matches exactly \e n occurrences of the expression. This
 	 is the same as repeating the expression \e n times. For
 	 example, <b>x{5}</b> is the same as <b>xxxxx</b>. It is also
 	 the same as <b>\e {E}{n,n}</b>, e.g. <b>x{5,5}</b>.
 
     \row \i <b>\e {E}{n,}</b>
 	 \i Matches at least \e n occurrences of the expression. This
 	 is the same as <b>\e {E}{n,MAXINT}</b>.
 
     \row \i <b>\e {E}{,m}</b>
 	 \i Matches at most \e m occurrences of the expression. This
 	 is the same as <b>\e {E}{0,m}</b>.
 
     \row \i <b>\e {E}{n,m}</b>
 	 \i Matches at least \e n occurrences of the expression and at
 	 most \e m occurrences of the expression.
     \endtable
 
     (MAXINT is implementation dependent but will not be smaller than
     1024.)
 
     If we wish to apply a quantifier to more than just the preceding
     character we can use parentheses to group characters together in
     an expression. For example, <b>tag+</b> matches a 't' followed by
     an 'a' followed by at least one 'g', whereas <b>(tag)+</b> matches
     at least one occurrence of 'tag'.
 
     Note that quantifiers are "greedy". They will match as much text
     as they can. For example, <b>0+</b> will match as many zeros as it
     can from the first zero it finds, e.g. '2.<u>000</u>5'.
     Quantifiers can be made non-greedy, see setMinimal().
 
     \target capturing-text
     \section1 Capturing Text
 
     Parentheses allow us to group elements together so that we can
     quantify and capture them. For example if we have the expression
     <b>mail|letter|correspondence</b> that matches a string we know
     that \e one of the words matched but not which one. Using
     parentheses allows us to "capture" whatever is matched within
     their bounds, so if we used <b>(mail|letter|correspondence)</b>
     and matched this regexp against the string "I sent you some email"
     we can use the cap() or capturedTexts() functions to extract the
     matched characters, in this case 'mail'.
 
     We can use captured text within the regexp itself. To refer to the
     captured text we use \e backreferences which are indexed from 1,
     the same as for cap(). For example we could search for duplicate
     words in a string using <b>\b(\w+)\W+\1\b</b> which means match a
     word boundary followed by one or more word characters followed by
     one or more non-word characters followed by the same text as the
     first parenthesised expression followed by a word boundary.
 
     If we want to use parentheses purely for grouping and not for
     capturing we can use the non-capturing syntax, e.g.
     <b>(?:green|blue)</b>. Non-capturing parentheses begin '(?:' and
     end ')'. In this example we match either 'green' or 'blue' but we
     do not capture the match so we only know whether or not we matched
     but not which color we actually found. Using non-capturing
     parentheses is more efficient than using capturing parentheses
     since the regexp engine has to do less book-keeping.
 
     Both capturing and non-capturing parentheses may be nested.
 
     \target assertions
     \section1 Assertions
 
     Assertions make some statement about the text at the point where
     they occur in the regexp but they do not match any characters. In
     the following list <b>\e {E}</b> stands for any expression.
 
     \table
     \row \i <b>^</b>
 	 \i The caret signifies the beginning of the string. If you
 	 wish to match a literal \c{^} you must escape it by
 	 writing \c{\\^}. For example, <b>^#include</b> will only
 	 match strings which \e begin with the characters '#include'.
 	 (When the caret is the first character of a character set it
 	 has a special meaning, see \link #sets-of-characters Sets of
 	 Characters \endlink.)
 
     \row \i <b>$</b>
 	 \i The dollar signifies the end of the string. For example
 	 <b>\d\s*$</b> will match strings which end with a digit
 	 optionally followed by whitespace. If you wish to match a
 	 literal \c{$} you must escape it by writing
 	 \c{\\$}.
 
     \row \i <b>\\b</b>
 	 \i A word boundary. For example the regexp
 	 <b>\\bOK\\b</b> means match immediately after a word
 	 boundary (e.g. start of string or whitespace) the letter 'O'
 	 then the letter 'K' immediately before another word boundary
 	 (e.g. end of string or whitespace). But note that the
 	 assertion does not actually match any whitespace so if we
 	 write <b>(\\bOK\\b)</b> and we have a match it will only
 	 contain 'OK' even if the string is "Its <u>OK</u> now".
 
     \row \i <b>\\B</b>
 	 \i A non-word boundary. This assertion is true wherever
 	 <b>\\b</b> is false. For example if we searched for
 	 <b>\\Bon\\B</b> in "Left on" the match would fail (space
 	 and end of string aren't non-word boundaries), but it would
 	 match in "t<u>on</u>ne".
 
     \row \i <b>(?=\e E)</b>
 	 \i Positive lookahead. This assertion is true if the
 	 expression matches at this point in the regexp. For example,
 	 <b>const(?=\\s+char)</b> matches 'const' whenever it is
 	 followed by 'char', as in 'static <u>const</u> char *'.
 	 (Compare with <b>const\\s+char</b>, which matches 'static
 	 <u>const char</u> *'.)
 
     \row \i <b>(?!\e E)</b>
 	 \i Negative lookahead. This assertion is true if the
 	 expression does not match at this point in the regexp. For
 	 example, <b>const(?!\\s+char)</b> matches 'const' \e except
 	 when it is followed by 'char'.
     \endtable
 
     \target wildcard-matching
     \section1 Wildcard Matching (globbing)
 
     Most command shells such as \e bash or \e cmd.exe support "file
     globbing", the ability to identify a group of files by using
     wildcards. The setWildcard() function is used to switch between
     regexp and wildcard mode. Wildcard matching is much simpler than
     full regexps and has only four features:
 
     \table
     \row \i <b>c</b>
 	 \i Any character represents itself apart from those mentioned
 	 below. Thus <b>c</b> matches the character \e c.
     \row \i <b>?</b>
 	 \i This matches any single character. It is the same as
 	 <b>.</b> in full regexps.
     \row \i <b>*</b>
 	 \i This matches zero or more of any characters. It is the
 	 same as <b>.*</b> in full regexps.
     \row \i <b>[...]</b>
 	 \i Sets of characters can be represented in square brackets,
 	 similar to full regexps. Within the character class, like
 	 outside, backslash has no special meaning.
     \endtable
 
     For example if we are in wildcard mode and have strings which
     contain filenames we could identify HTML files with <b>*.html</b>.
     This will match zero or more characters followed by a dot followed
     by 'h', 't', 'm' and 'l'.
 
     \target perl-users
     \section1 Notes for Perl Users
 
     Most of the character class abbreviations supported by Perl are
     supported by QRegExp, see \link
     #characters-and-abbreviations-for-sets-of-characters characters
     and abbreviations for sets of characters \endlink.
 
     In QRegExp, apart from within character classes, \c{^} always
     signifies the start of the string, so carets must always be
     escaped unless used for that purpose. In Perl the meaning of caret
     varies automagically depending on where it occurs so escaping it
     is rarely necessary. The same applies to \c{$} which in
     QRegExp always signifies the end of the string.
 
     QRegExp's quantifiers are the same as Perl's greedy quantifiers.
     Non-greedy matching cannot be applied to individual quantifiers,
     but can be applied to all the quantifiers in the pattern. For
     example, to match the Perl regexp <b>ro+?m</b> requires:
     \code
     QRegExp rx( "ro+m" );
     rx.setMinimal( TRUE );
     \endcode
 
     The equivalent of Perl's \c{/i} option is
     setCaseSensitive(FALSE).
 
     Perl's \c{/g} option can be emulated using a \link
     #cap_in_a_loop loop \endlink.
 
     In QRegExp <b>.</b> matches any character, therefore all QRegExp
     regexps have the equivalent of Perl's \c{/s} option. QRegExp
     does not have an equivalent to Perl's \c{/m} option, but this
     can be emulated in various ways for example by splitting the input
     into lines or by looping with a regexp that searches for newlines.
 
     Because QRegExp is string oriented there are no \A, \Z or \z
     assertions. The \G assertion is not supported but can be emulated
     in a loop.
 
     Perl's $& is cap(0) or capturedTexts()[0]. There are no QRegExp
     equivalents for $`, $' or $+. Perl's capturing variables, $1, $2,
     ... correspond to cap(1) or capturedTexts()[1], cap(2) or
     capturedTexts()[2], etc.
 
     To substitute a pattern use QString::replace().
 
     Perl's extended \c{/x} syntax is not supported, nor are
-    regexp comments (?#comment) or directives, e.g. (?i).
+    directives, e.g. (?i), or regexp comments, e.g. (?#comment). On
+    the other hand, C++'s rules for literal strings can be used to
+    achieve the same:
+    \code
+    QRegExp mark( "\\b" // word boundary
+		  "[Mm]ark" // the word we want to match
+		);
+    \endcode
 
     Both zero-width positive and zero-width negative lookahead
     assertions (?=pattern) and (?!pattern) are supported with the same
     syntax as Perl. Perl's lookbehind assertions, "independent"
     subexpressions and conditional expressions are not supported.
 
     Non-capturing parentheses are also supported, with the same
     (?:pattern) syntax.
 
     See QStringList::split() and QStringList::join() for equivalents
     to Perl's split and join functions.
 
     Note: because C++ transforms \\'s they must be written \e twice in
     code, e.g. <b>\\b</b> must be written <b>\\\\b</b>.
 
     \target code-examples
     \section1 Code Examples
 
     \code
     QRegExp rx( "^\\d\\d?$" );  // match integers 0 to 99
     rx.search( "123" );         // returns -1 (no match)
     rx.search( "-6" );          // returns -1 (no match)
     rx.search( "6" );           // returns 0 (matched as position 0)
     \endcode
 
     The third string matches '<u>6</u>'. This is a simple validation
     regexp for integers in the range 0 to 99.
 
     \code
     QRegExp rx( "^\\S+$" );     // match strings without whitespace
     rx.search( "Hello world" ); // returns -1 (no match)
     rx.search( "This_is-OK" );  // returns 0 (matched at position 0)
     \endcode
 
     The second string matches '<u>This_is-OK</u>'. We've used the
     character set abbreviation '\S' (non-whitespace) and the anchors
     to match strings which contain no whitespace.
 
     In the following example we match strings containing 'mail' or
     'letter' or 'correspondence' but only match whole words i.e. not
     'email'
 
     \code
     QRegExp rx( "\\b(mail|letter|correspondence)\\b" );
     rx.search( "I sent you an email" );     // returns -1 (no match)
     rx.search( "Please write the letter" ); // returns 17
     \endcode
 
     The second string matches "Please write the <u>letter</u>". The
     word 'letter' is also captured (because of the parentheses). We
     can see what text we've captured like this:
 
     \code
     QString captured = rx.cap( 1 ); // captured == "letter"
     \endcode
 
     This will capture the text from the first set of capturing
     parentheses (counting capturing left parentheses from left to
     right). The parentheses are counted from 1 since cap( 0 ) is the
     whole matched regexp (equivalent to '&' in most regexp engines).
 
     \code
     QRegExp rx( "&(?!amp;)" );      // match ampersands but not &amp;
     QString line1 = "This & that";
     line1.replace( rx, "&amp;" );
     // line1 == "This &amp; that"
     QString line2 = "His &amp; hers & theirs";
     line2.replace( rx, "&amp;" );
     // line2 == "His &amp; hers &amp; theirs"
     \endcode
 
     Here we've passed the QRegExp to QString's replace() function to
     replace the matched text with new text.
 
     \code
     QString str = "One Eric another Eirik, and an Ericsson."
 		    " How many Eiriks, Eric?";
     QRegExp rx( "\\b(Eric|Eirik)\\b" ); // match Eric or Eirik
     int pos = 0;    // where we are in the string
     int count = 0;  // how many Eric and Eirik's we've counted
     while ( pos >= 0 ) {
 	pos = rx.search( str, pos );
 	if ( pos >= 0 ) {
 	    pos++;      // move along in str
 	    count++;    // count our Eric or Eirik
 	}
     }
     \endcode
 
     We've used the search() function to repeatedly match the regexp in
     the string. Note that instead of moving forward by one character
     at a time \c pos++ we could have written \c {pos +=
     rx.matchedLength()} to skip over the already matched string. The
     count will equal 3, matching 'One <u>Eric</u> another
     <u>Eirik</u>, and an Ericsson. How many Eiriks, <u>Eric</u>?'; it
     doesn't match 'Ericsson' or 'Eiriks' because they are not bounded
     by non-word boundaries.
 
     One common use of regexps is to split lines of delimited data into
     their component fields.
 
     \code
     str = "Trolltech AS\twww.trolltech.com\tNorway";
     QString company, web, country;
     rx.setPattern( "^([^\t]+)\t([^\t]+)\t([^\t]+)$" );
     if ( rx.search( str ) != -1 ) {
 	company = rx.cap( 1 );
 	web = rx.cap( 2 );
 	country = rx.cap( 3 );
     }
     \endcode
 
     In this example our input lines have the format company name, web
     address and country. Unfortunately the regexp is rather long and
     not very versatile -- the code will break if we add any more
     fields. A simpler and better solution is to look for the
     separator, '\t' in this case, and take the surrounding text. The
     QStringList split() function can take a separator string or regexp
     as an argument and split a string accordingly.
 
     \code
     QStringList field = QStringList::split( "\t", str );
     \endcode
 
     Here field[0] is the company, field[1] the web address and so on.
 
     To imitate the matching of a shell we can use wildcard mode.
 
     \code
-    QRegExp rx( "*.html" );     // invalid regexp: * doesn't quantify anything
-    rx.setWildcard( TRUE );     // now it's a valid wildcard regexp
-    rx.search( "index.html" );  // returns 0 (matched at position 0)
-    rx.search( "default.htm" ); // returns -1 (no match)
-    rx.search( "readme.txt" );  // returns -1 (no match)
+    QRegExp rx( "*.html" );         // invalid regexp: * doesn't quantify anything
+    rx.setWildcard( TRUE );         // now it's a valid wildcard regexp
+    rx.exactMatch( "index.html" );  // returns TRUE
+    rx.exactMatch( "default.htm" ); // returns FALSE
+    rx.exactMatch( "readme.txt" );  // returns FALSE
     \endcode
 
     Wildcard matching can be convenient because of its simplicity, but
     any wildcard regexp can be defined using full regexps, e.g.
     <b>.*\.html$</b>. Notice that we can't match both \c .html and \c
     .htm files with a wildcard unless we use <b>*.htm*</b> which will
     also match 'test.html.bak'. A full regexp gives us the precision
     we need, <b>.*\\.html?$</b>.
 
     QRegExp can match case insensitively using setCaseSensitive(), and
     can use non-greedy matching, see setMinimal(). By default QRegExp
     uses full regexps but this can be changed with setWildcard().
     Searching can be forward with search() or backward with
     searchRev(). Captured text can be accessed using capturedTexts()
     which returns a string list of all captured strings, or using
     cap() which returns the captured string for the given index. The
     pos() function takes a match index and returns the position in the
     string where the match was made (or -1 if there was no match).
 
     \sa QRegExpValidator QString QStringList
 
     \target member-function-documentation
 */
 
 const int NumBadChars = 64;
 #define BadChar( ch ) ( (ch).unicode() % NumBadChars )
 
 const int NoOccurrence = INT_MAX;
 const int EmptyCapture = INT_MAX;
 const int InftyLen = INT_MAX;
 const int InftyRep = 1025;
 const int EOS = -1;
 
+static bool isWord( QChar ch )
+{
+    return ch.isLetterOrNumber() || ch == QChar( '_' );
+}
+
 /*
   Merges two QMemArrays of ints and puts the result into the first one.
 */
 static void mergeInto( QMemArray<int> *a, const QMemArray<int>& b )
 {
     int asize = a->size();
     int bsize = b.size();
     if ( asize == 0 ) {
 	*a = b.copy();
 #ifndef QT_NO_REGEXP_OPTIM
     } else if ( bsize == 1 && (*a)[asize - 1] < b[0] ) {
 	a->resize( asize + 1 );
 	(*a)[asize] = b[0];
 #endif
     } else if ( bsize >= 1 ) {
 	int csize = asize + bsize;
 	QMemArray<int> c( csize );
 	int i = 0, j = 0, k = 0;
 	while ( i < asize ) {
 	    if ( j < bsize ) {
 		if ( (*a)[i] == b[j] ) {
 		    i++;
 		    csize--;
 		} else if ( (*a)[i] < b[j] ) {
 		    c[k++] = (*a)[i++];
 		} else {
 		    c[k++] = b[j++];
 		}
 	    } else {
 		memcpy( c.data() + k, (*a).data() + i,
 			(asize - i) * sizeof(int) );
 		break;
 	    }
 	}
 	c.resize( csize );
 	if ( j < bsize )
 	    memcpy( c.data() + k, b.data() + j, (bsize - j) * sizeof(int) );
 	*a = c;
     }
 }
 
 /*
   Merges two disjoint QMaps of (int, int) pairs and puts the result into the
   first one.
 */
 static void mergeInto( QMap<int, int> *a, const QMap<int, int>& b )
 {
     QMap<int, int>::ConstIterator it;
     for ( it = b.begin(); it != b.end(); ++it )
 	a->insert( it.key(), *it );
 }
 
 /*
   Returns the value associated to key k in QMap m of (int, int) pairs, or 0 if
   no such value is explicitly present.
 */
 static int at( const QMap<int, int>& m, int k )
 {
     QMap<int, int>::ConstIterator it = m.find( k );
     if ( it == m.end() )
 	return 0;
     else
 	return *it;
 }
 
 #ifndef QT_NO_REGEXP_WILDCARD
 /*
   Translates a wildcard pattern to an equivalent regular expression pattern
   (e.g., *.cpp to .*\.cpp).
 */
 static QString wc2rx( const QString& wc_str )
 {
     int wclen = wc_str.length();
     QString rx = QString::fromLatin1( "" );
     int i = 0;
     const QChar *wc = wc_str.unicode();
     while ( i < wclen ) {
 	QChar c = wc[i++];
 	switch ( c.unicode() ) {
 	case '*':
 	    rx += QString::fromLatin1( ".*" );
 	    break;
 	case '?':
 	    rx += QChar( '.' );
 	    break;
 	case '$':
 	case '(':
 	case ')':
 	case '+':
 	case '.':
 	case '\\':
 	case '^':
 	case '{':
 	case '|':
 	case '}':
 	    rx += QChar( '\\' );
 	    rx += c;
 	    break;
 	case '[':
 	    rx += c;
 	    if ( wc[i] == QChar('^') )
 		rx += wc[i++];
 	    if ( i < wclen ) {
 		if ( rx[i] == ']' )
 		    rx += wc[i++];
 		while ( i < wclen && wc[i] != QChar(']') ) {
 		    if ( wc[i] == '\\' )
 			rx += QChar( '\\' );
 		    rx += wc[i++];
 		}
 	    }
 	    break;
 	default:
 	    rx += c;
 	}
     }
     return rx;
 }
 #endif
 
 /*
   The class QRegExpEngine encapsulates a modified nondeterministic
   finite automaton (NFA).
 */
 class QRegExpEngine : public QShared
 {
 public:
 #ifndef QT_NO_REGEXP_CCLASS
     /*
       The class CharClass represents a set of characters, such as can
       be found in regular expressions (e.g., [a-z] denotes the set
       {a, b, ..., z}).
     */
     class CharClass
     {
     public:
 	CharClass();
 	CharClass( const CharClass& cc ) { operator=( cc ); }
 
 	CharClass& operator=( const CharClass& cc );
 
 	void clear();
 	bool negative() const { return n; }
 	void setNegative( bool negative );
 	void addCategories( int cats );
 	void addRange( ushort from, ushort to );
 	void addSingleton( ushort ch ) { addRange( ch, ch ); }
 
 	bool in( QChar ch ) const;
 #ifndef QT_NO_REGEXP_OPTIM
 	const QMemArray<int>& firstOccurrence() const { return occ1; }
 #endif
 
 #if defined(QT_DEBUG)
 	void dump() const;
 #endif
 
     private:
 	/*
 	  The struct Range represents a range of characters (e.g.,
 	  [0-9] denotes range 48 to 57).
 	*/
 	struct Range
 	{
 	    ushort from; // 48
 	    ushort to; // 57
 	};
 
 	int c; // character classes
 	QMemArray<Range> r; // character ranges
 	bool n; // negative?
 #ifndef QT_NO_REGEXP_OPTIM
 	QMemArray<int> occ1; // first-occurrence array
 #endif
     };
 #else
     struct CharClass
     {
 	int dummy;
 
 #ifndef QT_NO_REGEXP_OPTIM
 	CharClass() { occ1.fill( 0, NumBadChars ); }
 
 	const QMemArray<int>& firstOccurrence() const { return occ1; }
 	QMemArray<int> occ1;
 #endif
     };
 #endif
 
     QRegExpEngine( bool caseSensitive ) { setup( caseSensitive ); }
     QRegExpEngine( const QString& rx, bool caseSensitive );
 #ifndef QT_NO_REGEXP_OPTIM
     ~QRegExpEngine();
 #endif
 
     bool isValid() const { return valid; }
     const QString& errorString() const { return yyError; }
     bool caseSensitive() const { return cs; }
     int numCaptures() const { return officialncap; }
     QMemArray<int> match( const QString& str, int pos, bool minimal,
 			  bool oneTest, int caretIndex );
     int matchedLength() const { return mmMatchedLen; }
 
     int createState( QChar ch );
     int createState( const CharClass& cc );
 #ifndef QT_NO_REGEXP_BACKREF
     int createState( int bref );
 #endif
 
     void addCatTransitions( const QMemArray<int>& from,
 			    const QMemArray<int>& to );
 #ifndef QT_NO_REGEXP_CAPTURE
     void addPlusTransitions( const QMemArray<int>& from,
 			     const QMemArray<int>& to, int atom );
 #endif
 
 #ifndef QT_NO_REGEXP_ANCHOR_ALT
     int anchorAlternation( int a, int b );
     int anchorConcatenation( int a, int b );
 #else
     int anchorAlternation( int a, int b ) { return a & b; }
     int anchorConcatenation( int a, int b ) { return a | b; }
 #endif
     void addAnchors( int from, int to, int a );
 
 #ifndef QT_NO_REGEXP_OPTIM
     void setupGoodStringHeuristic( int earlyStart, int lateStart,
 				   const QString& str );
     void setupBadCharHeuristic( int minLen, const QMemArray<int>& firstOcc );
     void heuristicallyChooseHeuristic();
 #endif
 
 #if defined(QT_DEBUG)
     void dump() const;
 #endif
 
 private:
     enum { CharClassBit = 0x10000, BackRefBit = 0x20000 };
 
     /*
       The struct State represents one state in a modified NFA. The
       input characters matched are stored in the state instead of on
       the transitions, something possible for an automaton
       constructed from a regular expression.
     */
     struct State
     {
 #ifndef QT_NO_REGEXP_CAPTURE
 	int atom; // which atom does this state belong to?
 #endif
 	int match; // what does it match? (see CharClassBit and BackRefBit)
 	QMemArray<int> outs; // out-transitions
 	QMap<int, int> *reenter; // atoms reentered when transiting out
 	QMap<int, int> *anchors; // anchors met when transiting out
 
 #ifndef QT_NO_REGEXP_CAPTURE
 	State( int a, int m )
 	    : atom( a ), match( m ), reenter( 0 ), anchors( 0 ) { }
 #else
 	State( int m )
 	    : match( m ), reenter( 0 ), anchors( 0 ) { }
 #endif
 	~State() { delete reenter; delete anchors; }
     };
 
 #ifndef QT_NO_REGEXP_LOOKAHEAD
     /*
       The struct Lookahead represents a lookahead a la Perl (e.g., (?=foo) and
       (?!bar)).
     */
     struct Lookahead
     {
 	QRegExpEngine *eng; // NFA representing the embedded regular expression
 	bool neg; // negative lookahead?
 
 	Lookahead( QRegExpEngine *eng0, bool neg0 )
 	    : eng( eng0 ), neg( neg0 ) { }
 	~Lookahead() { delete eng; }
     };
 #endif
 
 #ifndef QT_NO_REGEXP_CAPTURE
     /*
       The struct Atom represents one node in the hierarchy of regular
       expression atoms.
     */
     struct Atom
     {
 	int parent; // index of parent in array of atoms
 	int capture; // index of capture, from 1 to ncap
     };
 #endif
 
 #ifndef QT_NO_REGEXP_ANCHOR_ALT
     /*
       The struct AnchorAlternation represents a pair of anchors with
       OR semantics.
     */
     struct AnchorAlternation
     {
 	int a; // this anchor...
 	int b; // ...or this one
     };
 #endif
 
     enum { InitialState = 0, FinalState = 1 };
     void setup( bool caseSensitive );
     int setupState( int match );
 
     /*
       Let's hope that 13 lookaheads and 14 back-references are
       enough.
      */
     enum { MaxLookaheads = 13, MaxBackRefs = 14 };
     enum { Anchor_Dollar = 0x00000001, Anchor_Caret = 0x00000002,
 	   Anchor_Word = 0x00000004, Anchor_NonWord = 0x00000008,
 	   Anchor_FirstLookahead = 0x00000010,
 	   Anchor_BackRef1Empty = Anchor_FirstLookahead << MaxLookaheads,
 	   Anchor_BackRef0Empty = Anchor_BackRef1Empty >> 1,
 	   Anchor_Alternation = Anchor_BackRef1Empty << MaxBackRefs,
 
 	   Anchor_LookaheadMask = ( Anchor_FirstLookahead - 1 ) ^
 		   ( (Anchor_FirstLookahead << MaxLookaheads) - 1 ) };
 #ifndef QT_NO_REGEXP_CAPTURE
     int startAtom( bool capture );
     void finishAtom( int atom ) { cf = f[atom].parent; }
 #endif
 
 #ifndef QT_NO_REGEXP_LOOKAHEAD
     int addLookahead( QRegExpEngine *eng, bool negative );
 #endif
 
 #ifndef QT_NO_REGEXP_CAPTURE
     bool isBetterCapture( const int *begin1, const int *end1, const int *begin2,
 			  const int *end2 );
 #endif
     bool testAnchor( int i, int a, const int *capBegin );
 
 #ifndef QT_NO_REGEXP_OPTIM
     bool goodStringMatch();
     bool badCharMatch();
 #else
     bool bruteMatch();
 #endif
     bool matchHere();
 
     QPtrVector<State> s; // array of states
     int ns; // number of states
 #ifndef QT_NO_REGEXP_CAPTURE
     QMemArray<Atom> f; // atom hierarchy
     int nf; // number of atoms
     int cf; // current atom
 #endif
     int officialncap; // number of captures, seen from the outside
     int ncap; // number of captures, seen from the inside
 #ifndef QT_NO_REGEXP_CCLASS
     QPtrVector<CharClass> cl; // array of character classes
 #endif
 #ifndef QT_NO_REGEXP_LOOKAHEAD
     QPtrVector<Lookahead> ahead; // array of lookaheads
 #endif
 #ifndef QT_NO_REGEXP_ANCHOR_ALT
     QMemArray<AnchorAlternation> aa; // array of (a, b) pairs of anchors
 #endif
 #ifndef QT_NO_REGEXP_OPTIM
     bool caretAnchored; // does the regexp start with ^?
 #endif
     bool valid; // is the regular expression valid?
     bool cs; // case sensitive?
 #ifndef QT_NO_REGEXP_BACKREF
     int nbrefs; // number of back-references
 #endif
 
 #ifndef QT_NO_REGEXP_OPTIM
     bool useGoodStringHeuristic; // use goodStringMatch? otherwise badCharMatch
 
     int goodEarlyStart; // the index where goodStr can first occur in a match
     int goodLateStart; // the index where goodStr can last occur in a match
     QString goodStr; // the string that any match has to contain
 
     int minl; // the minimum length of a match
     QMemArray<int> occ1; // first-occurrence array
 #endif
 
     /*
       The class Box is an abstraction for a regular expression
       fragment. It can also be seen as one node in the syntax tree of
       a regular expression with synthetized attributes.
 
       It's interface is ugly for performance reasons.
     */
     class Box
     {
     public:
 	Box( QRegExpEngine *engine );
 	Box( const Box& b ) { operator=( b ); }
 
 	Box& operator=( const Box& b );
 
 	void clear() { operator=(Box(eng)); }
 	void set( QChar ch );
 	void set( const CharClass& cc );
 #ifndef QT_NO_REGEXP_BACKREF
 	void set( int bref );
 #endif
 
 	void cat( const Box& b );
 	void orx( const Box& b );
 	void plus( int atom );
 	void opt();
 	void catAnchor( int a );
 #ifndef QT_NO_REGEXP_OPTIM
 	void setupHeuristics();
 #endif
 
 #if defined(QT_DEBUG)
 	void dump() const;
 #endif
 
     private:
 	void addAnchorsToEngine( const Box& to ) const;
 
 	QRegExpEngine *eng; // the automaton under construction
 	QMemArray<int> ls; // the left states (firstpos)
 	QMemArray<int> rs; // the right states (lastpos)
 	QMap<int, int> lanchors; // the left anchors
 	QMap<int, int> ranchors; // the right anchors
 	int skipanchors; // the anchors to match if the box is skipped
 
 #ifndef QT_NO_REGEXP_OPTIM
 	int earlyStart; // the index where str can first occur
 	int lateStart; // the index where str can last occur
 	QString str; // a string that has to occur in any match
 	QString leftStr; // a string occurring at the left of this box
 	QString rightStr; // a string occurring at the right of this box
 	int maxl; // the maximum length of this box (possibly InftyLen)
 #endif
 
 	int minl; // the minimum length of this box
 #ifndef QT_NO_REGEXP_OPTIM
 	QMemArray<int> occ1; // first-occurrence array
 #endif
     };
     friend class Box;
 
     /*
       This is the lexical analyzer for regular expressions.
     */
     enum { Tok_Eos, Tok_Dollar, Tok_LeftParen, Tok_MagicLeftParen,
 	   Tok_PosLookahead, Tok_NegLookahead, Tok_RightParen, Tok_CharClass,
 	   Tok_Caret, Tok_Quantifier, Tok_Bar, Tok_Word, Tok_NonWord,
 	   Tok_Char = 0x10000, Tok_BackRef = 0x20000 };
     int getChar();
     int getEscape();
 #ifndef QT_NO_REGEXP_INTERVAL
     int getRep( int def );
 #endif
 #ifndef QT_NO_REGEXP_LOOKAHEAD
     void skipChars( int n );
 #endif
     void error( const char *msg );
     void startTokenizer( const QChar *rx, int len );
     int getToken();
 
     const QChar *yyIn; // a pointer to the input regular expression pattern
     int yyPos0; // the position of yyTok in the input pattern
     int yyPos; // the position of the next character to read
     int yyLen; // the length of yyIn
     int yyCh; // the last character read
     CharClass *yyCharClass; // attribute for Tok_CharClass tokens
     int yyMinRep; // attribute for Tok_Quantifier
     int yyMaxRep; // ditto
     QString yyError; // syntax error or overflow during parsing?
 
     /*
       This is the syntactic analyzer for regular expressions.
     */
     int parse( const QChar *rx, int len );
     void parseAtom( Box *box );
     void parseFactor( Box *box );
     void parseTerm( Box *box );
     void parseExpression( Box *box );
 
     int yyTok; // the last token read
     bool yyMayCapture; // set this to FALSE to disable capturing
 
     /*
       This is the engine state during matching.
     */
     const QString *mmStr; // a pointer to the input QString
     const QChar *mmIn; // a pointer to the input string data
     int mmPos; // the current position in the string
     int mmCaretPos;
     int mmLen; // the length of the input string
     bool mmMinimal; // minimal matching?
     QMemArray<int> mmCaptured; // an array of pairs (start, len)
     QMemArray<int> mmCapturedNoMatch; // an array of pairs (-1, -1)
     QMemArray<int> mmBigArray; // big QMemArray<int> array
     int *mmInNextStack; // is state is mmNextStack?
     int *mmCurStack; // stack of current states
     int *mmNextStack; // stack of next states
     int *mmCurCapBegin; // start of current states' captures
     int *mmNextCapBegin; // start of next states' captures
     int *mmCurCapEnd; // end of current states' captures
     int *mmNextCapEnd; // end of next states' captures
     int *mmTempCapBegin; // start of temporary captures
     int *mmTempCapEnd; // end of temporary captures
     int *mmCapBegin; // start of captures for a next state
     int *mmCapEnd; // end of captures for a next state
     int *mmSlideTab; // bump-along slide table for bad-character heuristic
     int mmSlideTabSize; // size of slide table
 #ifndef QT_NO_REGEXP_BACKREF
     QIntDict<int> mmSleeping; // dictionary of back-reference sleepers
 #endif
     int mmMatchLen; // length of match
     int mmMatchedLen; // length of partial match
 };
 
 QRegExpEngine::QRegExpEngine( const QString& rx, bool caseSensitive )
 #ifndef QT_NO_REGEXP_BACKREF
     : mmSleeping( 101 )
 #endif
 {
     setup( caseSensitive );
     valid = ( parse(rx.unicode(), rx.length()) == (int) rx.length() );
     if ( !valid )
 	error( RXERR_LEFTDELIM );
 }
 
 #ifndef QT_NO_REGEXP_OPTIM
 QRegExpEngine::~QRegExpEngine()
 {
 }
 #endif
 
 /*
   Tries to match in str and returns an array of (begin, length) pairs
   for captured text. If there is no match, all pairs are (-1, -1).
 */
 QMemArray<int> QRegExpEngine::match( const QString& str, int pos, bool minimal,
 				     bool oneTest, int caretIndex )
 {
     mmStr = &str;
     mmIn = str.unicode();
     if ( mmIn == 0 )
 	mmIn = &QChar::null;
     mmPos = pos;
     mmCaretPos = caretIndex;
     mmLen = str.length();
     mmMinimal = minimal;
     mmMatchLen = 0;
     mmMatchedLen = 0;
 
     bool matched = FALSE;
     if ( valid && mmPos >= 0 && mmPos <= mmLen ) {
 #ifndef QT_NO_REGEXP_OPTIM
 	if ( oneTest ) {
 	    matched = matchHere();
 	} else {
 	    if ( mmPos <= mmLen - minl ) {
 		if ( caretAnchored ) {
 		    matched = matchHere();
 		} else if ( useGoodStringHeuristic ) {
 		    matched = goodStringMatch();
 		} else {
 		    matched = badCharMatch();
 		}
 	    }
 	}
 #else
 	matched = oneTest ? matchHere() : bruteMatch();
 #endif
     }
 
     if ( matched ) {
 	mmCaptured.detach();
 	mmCaptured[0] = mmPos;
 	mmCaptured[1] = mmMatchLen;
 	for ( int j = 0; j < officialncap; j++ ) {
 	    int len = mmCapEnd[j] - mmCapBegin[j];
 	    mmCaptured[2 + 2 * j] = len > 0 ? mmPos + mmCapBegin[j] : 0;
 	    mmCaptured[2 + 2 * j + 1] = len;
 	}
 	return mmCaptured;
     } else {
 	return mmCapturedNoMatch;
     }
 }
 
 /*
   The three following functions add one state to the automaton and
   return the number of the state.
 */
 
 int QRegExpEngine::createState( QChar ch )
 {
     return setupState( ch.unicode() );
 }
 
 int QRegExpEngine::createState( const CharClass& cc )
 {
 #ifndef QT_NO_REGEXP_CCLASS
     int n = cl.size();
     cl.resize( n + 1 );
     cl.insert( n, new CharClass(cc) );
     return setupState( CharClassBit | n );
 #else
     Q_UNUSED( cc );
     return setupState( CharClassBit );
 #endif
 }
 
 #ifndef QT_NO_REGEXP_BACKREF
 int QRegExpEngine::createState( int bref )
 {
     if ( bref > nbrefs ) {
 	nbrefs = bref;
 	if ( nbrefs > MaxBackRefs ) {
 	    error( RXERR_LIMIT );
 	    return 0;
 	}
     }
     return setupState( BackRefBit | bref );
 }
 #endif
 
 /*
   The two following functions add a transition between all pairs of
   states (i, j) where i is fond in from, and j is found in to.
 
   Cat-transitions are distinguished from plus-transitions for
   capturing.
 */
 
 void QRegExpEngine::addCatTransitions( const QMemArray<int>& from,
 				       const QMemArray<int>& to )
 {
     for ( int i = 0; i < (int) from.size(); i++ ) {
 	State *st = s[from[i]];
 	mergeInto( &st->outs, to );
     }
 }
 
 #ifndef QT_NO_REGEXP_CAPTURE
 void QRegExpEngine::addPlusTransitions( const QMemArray<int>& from,
 					const QMemArray<int>& to, int atom )
 {
     for ( int i = 0; i < (int) from.size(); i++ ) {
 	State *st = s[from[i]];
 	QMemArray<int> oldOuts = st->outs.copy();
 	mergeInto( &st->outs, to );
 	if ( f[atom].capture >= 0 ) {
 	    if ( st->reenter == 0 )
 		st->reenter = new QMap<int, int>;
 	    for ( int j = 0; j < (int) to.size(); j++ ) {
 		if ( !st->reenter->contains(to[j]) &&
 		     oldOuts.bsearch(to[j]) < 0 )
 		    st->reenter->insert( to[j], atom );
 	    }
 	}
     }
 }
 #endif
 
 #ifndef QT_NO_REGEXP_ANCHOR_ALT
 /*
   Returns an anchor that means a OR b.
 */
 int QRegExpEngine::anchorAlternation( int a, int b )
 {
     if ( ((a & b) == a || (a & b) == b) && ((a | b) & Anchor_Alternation) == 0 )
 	return a & b;
 
     int n = aa.size();
 #ifndef QT_NO_REGEXP_OPTIM
     if ( n > 0 && aa[n - 1].a == a && aa[n - 1].b == b )
 	return Anchor_Alternation | ( n - 1 );
 #endif
 
     aa.resize( n + 1 );
     aa[n].a = a;
     aa[n].b = b;
     return Anchor_Alternation | n;
 }
 
 /*
   Returns an anchor that means a AND b.
 */
 int QRegExpEngine::anchorConcatenation( int a, int b )
 {
     if ( ((a | b) & Anchor_Alternation) == 0 )
 	return a | b;
     if ( (b & Anchor_Alternation) != 0 )
 	qSwap( a, b );
 
     int aprime = anchorConcatenation( aa[a ^ Anchor_Alternation].a, b );
     int bprime = anchorConcatenation( aa[a ^ Anchor_Alternation].b, b );
     return anchorAlternation( aprime, bprime );
 }
 #endif
 
 /*
   Adds anchor a on a transition caracterised by its from state and
   its to state.
 */
 void QRegExpEngine::addAnchors( int from, int to, int a )
 {
     State *st = s[from];
     if ( st->anchors == 0 )
 	st->anchors = new QMap<int, int>;
     if ( st->anchors->contains(to) )
 	a = anchorAlternation( (*st->anchors)[to], a );
     st->anchors->insert( to, a );
 }
 
 #ifndef QT_NO_REGEXP_OPTIM
 /*
   The two following functions provide the engine with the information
   needed by its matching heuristics.
 */
 
 void QRegExpEngine::setupGoodStringHeuristic( int earlyStart, int lateStart,
 					      const QString& str )
 {
     goodEarlyStart = earlyStart;
     goodLateStart = lateStart;
     goodStr = cs ? str : str.lower();
 }
 
 void QRegExpEngine::setupBadCharHeuristic( int minLen,
 					   const QMemArray<int>& firstOcc )
 {
     minl = minLen;
     if ( cs ) {
 	occ1 = firstOcc;
     } else {
 	occ1.fill( 0, NumBadChars );
     }
 }
 
 /*
   This function chooses between the good-string and the bad-character
   heuristics. It computes two scores and chooses the heuristic with
   the highest score.
 
   Here are some common-sense constraints on the scores that should be
   respected if the formulas are ever modified: (1) If goodStr is
   empty, the good-string heuristic scores 0. (2) If the search is
   case insensitive, the good-string heuristic should be used, unless
   it scores 0. (Case insensitivity turns all entries of occ1 to 0.)
   (3) If (goodLateStart - goodEarlyStart) is big, the good-string
   heuristic should score less.
 */
 void QRegExpEngine::heuristicallyChooseHeuristic()
 {
     int i;
 
     if ( minl == 0 )
 	return;
 
     /*
       Magic formula:  The good string has to constitute a good
       proportion of the minimum-length string, and appear at a
       more-or-less known index.
     */
     int goodStringScore = ( 64 * goodStr.length() / minl ) -
 			  ( goodLateStart - goodEarlyStart );
 
     /*
       Less magic formula:  We pick a couple of characters at random,
       and check whether they are good or bad.
     */
     int badCharScore = 0;
     int step = QMAX( 1, NumBadChars / 32 );
     for ( i = 1; i < NumBadChars; i += step ) {
 	if ( occ1[i] == NoOccurrence )
 	    badCharScore += minl;
 	else
 	    badCharScore += occ1[i];
     }
     badCharScore /= minl;
 
     useGoodStringHeuristic = ( goodStringScore > badCharScore );
 }
 #endif
 
 #if defined(QT_DEBUG)
 void QRegExpEngine::dump() const
 {
     int i, j;
     qDebug( "Case %ssensitive engine", cs ? "" : "in" );
     qDebug( "  States" );
     for ( i = 0; i < ns; i++ ) {
 	qDebug( "  %d%s", i,
 		i == InitialState ? " (initial)" :
 		i == FinalState ? " (final)" : "" );
 #ifndef QT_NO_REGEXP_CAPTURE
 	qDebug( "    in atom %d", s[i]->atom );
 #endif
 	int m = s[i]->match;
 	if ( (m & CharClassBit) != 0 ) {
 	    qDebug( "    match character class %d", m ^ CharClassBit );
 #ifndef QT_NO_REGEXP_CCLASS
 	    cl[m ^ CharClassBit]->dump();
 #else
 	    qDebug( "    negative character class" );
 #endif
 	} else if ( (m & BackRefBit) != 0 ) {
 	    qDebug( "    match back-reference %d", m ^ BackRefBit );
 	} else if ( m >= 0x20 && m <= 0x7e ) {
 	    qDebug( "    match 0x%.4x (%c)", m, m );
 	} else {
 	    qDebug( "    match 0x%.4x", m );
 	}
 	for ( j = 0; j < (int) s[i]->outs.size(); j++ ) {
 	    int next = s[i]->outs[j];
 	    qDebug( "    -> %d", next );
 	    if ( s[i]->reenter != 0 && s[i]->reenter->contains(next) )
 		qDebug( "       [reenter %d]", (*s[i]->reenter)[next] );
 	    if ( s[i]->anchors != 0 && at(*s[i]->anchors, next) != 0 )
 		qDebug( "       [anchors 0x%.8x]", (*s[i]->anchors)[next] );
 	}
     }
 #ifndef QT_NO_REGEXP_CAPTURE
     if ( nf > 0 ) {
 	qDebug( "  Atom    Parent  Capture" );
 	for ( i = 0; i < nf; i++ )
 	    qDebug( "  %6d  %6d  %6d", i, f[i].parent, f[i].capture );
     }
 #endif
 #ifndef QT_NO_REGEXP_ANCHOR_ALT
     for ( i = 0; i < (int) aa.size(); i++ )
 	qDebug( "  Anchor alternation 0x%.8x: 0x%.8x 0x%.9x", i, aa[i].a,
 		aa[i].b );
 #endif
 }
 #endif
 
 void QRegExpEngine::setup( bool caseSensitive )
 {
     s.setAutoDelete( TRUE );
     s.resize( 32 );
     ns = 0;
 #ifndef QT_NO_REGEXP_CAPTURE
     f.resize( 32 );
     nf = 0;
     cf = -1;
 #endif
     officialncap = 0;
     ncap = 0;
 #ifndef QT_NO_REGEXP_CCLASS
     cl.setAutoDelete( TRUE );
 #endif
 #ifndef QT_NO_REGEXP_LOOKAHEAD
     ahead.setAutoDelete( TRUE );
 #endif
 #ifndef QT_NO_REGEXP_OPTIM
     caretAnchored = TRUE;
 #endif
     valid = FALSE;
     cs = caseSensitive;
 #ifndef QT_NO_REGEXP_BACKREF
     nbrefs = 0;
 #endif
 #ifndef QT_NO_REGEXP_OPTIM
     useGoodStringHeuristic = FALSE;
     minl = 0;
     occ1.fill( 0, NumBadChars );
 #endif
     mmCapturedNoMatch.fill( -1, 2 );
 }
 
 int QRegExpEngine::setupState( int match )
 {
     if ( (ns & (ns + 1)) == 0 && ns + 1 >= (int) s.size() )
 	s.resize( (ns + 1) << 1 );
 #ifndef QT_NO_REGEXP_CAPTURE
     s.insert( ns, new State(cf, match) );
 #else
     s.insert( ns, new State(match) );
 #endif
     return ns++;
 }
 
 #ifndef QT_NO_REGEXP_CAPTURE
 /*
   Functions startAtom() and finishAtom() should be called to delimit
   atoms. When a state is created, it is assigned to the current atom.
   The information is later used for capturing.
 */
 int QRegExpEngine::startAtom( bool capture )
 {
     if ( (nf & (nf + 1)) == 0 && nf + 1 >= (int) f.size() )
 	f.resize( (nf + 1) << 1 );
     f[nf].parent = cf;
     cf = nf++;
     f[cf].capture = capture ? ncap++ : -1;
     return cf;
 }
 #endif
 
 #ifndef QT_NO_REGEXP_LOOKAHEAD
 /*
   Creates a lookahead anchor.
 */
 int QRegExpEngine::addLookahead( QRegExpEngine *eng, bool negative )
 {
     int n = ahead.size();
     if ( n == MaxLookaheads ) {
 	error( RXERR_LIMIT );
 	return 0;
     }
     ahead.resize( n + 1 );
     ahead.insert( n, new Lookahead(eng, negative) );
     return Anchor_FirstLookahead << n;
 }
 #endif
 
 #ifndef QT_NO_REGEXP_CAPTURE
 /*
   We want the longest leftmost captures.
 */
 bool QRegExpEngine::isBetterCapture( const int *begin1, const int *end1,
 				     const int *begin2, const int *end2 )
 {
     for ( int i = 0; i < ncap; i++ ) {
 	int delta = begin2[i] - begin1[i]; // it has to start early...
 	if ( delta == 0 )
 	    delta = end1[i] - end2[i]; // ...and end late (like a party)
 
 	if ( delta != 0 )
 	    return delta > 0;
     }
     return FALSE;
 }
 #endif
 
 /*
   Returns TRUE if anchor a matches at position mmPos + i in the input
   string, otherwise FALSE.
 */
 bool QRegExpEngine::testAnchor( int i, int a, const int *capBegin )
 {
     int j;
 
 #ifndef QT_NO_REGEXP_ANCHOR_ALT
     if ( (a & Anchor_Alternation) != 0 ) {
 	return testAnchor( i, aa[a ^ Anchor_Alternation].a, capBegin ) ||
 	       testAnchor( i, aa[a ^ Anchor_Alternation].b, capBegin );
     }
 #endif
 
     if ( (a & Anchor_Caret) != 0 ) {
 	if ( mmPos + i != mmCaretPos )
 	    return FALSE;
     }
     if ( (a & Anchor_Dollar) != 0 ) {
 	if ( mmPos + i != mmLen )
 	    return FALSE;
     }
 #ifndef QT_NO_REGEXP_ESCAPE
     if ( (a & (Anchor_Word | Anchor_NonWord)) != 0 ) {
 	bool before = FALSE;
 	bool after = FALSE;
 	if ( mmPos + i != 0 )
-	    before = mmIn[mmPos + i - 1].isLetterOrNumber();
+	    before = isWord( mmIn[mmPos + i - 1] );
 	if ( mmPos + i != mmLen )
-	    after = mmIn[mmPos + i].isLetterOrNumber();
+	    after = isWord( mmIn[mmPos + i] );
 	if ( (a & Anchor_Word) != 0 && (before == after) )
 	    return FALSE;
 	if ( (a & Anchor_NonWord) != 0 && (before != after) )
 	    return FALSE;
     }
 #endif
 #ifndef QT_NO_REGEXP_LOOKAHEAD
     bool catchx = TRUE;
 
     if ( (a & Anchor_LookaheadMask) != 0 ) {
 	QConstString cstr = QConstString( (QChar *) mmIn + mmPos + i,
 					   mmLen - mmPos - i );
 	for ( j = 0; j < (int) ahead.size(); j++ ) {
 	    if ( (a & (Anchor_FirstLookahead << j)) != 0 ) {
 		catchx = ahead[j]->eng->match( cstr.string(), 0, TRUE, TRUE,
 					       mmCaretPos - mmPos - i )[0] == 0;
 		if ( catchx == ahead[j]->neg )
 		    return FALSE;
 	    }
 	}
     }
 #endif
 #ifndef QT_NO_REGEXP_CAPTURE
 #ifndef QT_NO_REGEXP_BACKREF
     for ( j = 0; j < nbrefs; j++ ) {
 	if ( (a & (Anchor_BackRef1Empty << j)) != 0 ) {
 	    if ( capBegin[j] != EmptyCapture )
 		return FALSE;
 	}
     }
 #endif
 #endif
     return TRUE;
 }
 
 #ifndef QT_NO_REGEXP_OPTIM
 /*
   The three following functions are what Jeffrey Friedl would call
   transmissions (or bump-alongs). Using one or the other should make
   no difference except in performance.
 */
 
 bool QRegExpEngine::goodStringMatch()
 {
     int k = mmPos + goodEarlyStart;
 
     while ( (k = mmStr->find(goodStr, k, cs)) != -1 ) {
 	int from = k - goodLateStart;
 	int to = k - goodEarlyStart;
 	if ( from > mmPos )
 	    mmPos = from;
 
 	while ( mmPos <= to ) {
 	    if ( matchHere() )
 		return TRUE;
 	    mmPos++;
 	}
 	k++;
     }
     return FALSE;
 }
 
 bool QRegExpEngine::badCharMatch()
 {
     int slideHead = 0;
     int slideNext = 0;
     int i;
     int lastPos = mmLen - minl;
     memset( mmSlideTab, 0, mmSlideTabSize * sizeof(int) );
 
     /*
       Set up the slide table, used for the bad-character heuristic,
       using the table of first occurrence of each character.
     */
     for ( i = 0; i < minl; i++ ) {
 	int sk = occ1[BadChar(mmIn[mmPos + i])];
 	if ( sk == NoOccurrence )
 	    sk = i + 1;
 	if ( sk > 0 ) {
 	    int k = i + 1 - sk;
 	    if ( k < 0 ) {
 		sk = i + 1;
 		k = 0;
 	    }
 	    if ( sk > mmSlideTab[k] )
 		mmSlideTab[k] = sk;
 	}
     }
 
     if ( mmPos > lastPos )
 	return FALSE;
 
     for ( ;; ) {
 	if ( ++slideNext >= mmSlideTabSize )
 	    slideNext = 0;
 	if ( mmSlideTab[slideHead] > 0 ) {
 	    if ( mmSlideTab[slideHead] - 1 > mmSlideTab[slideNext] )
 		mmSlideTab[slideNext] = mmSlideTab[slideHead] - 1;
 	    mmSlideTab[slideHead] = 0;
 	} else {
 	    if ( matchHere() )
 		return TRUE;
 	}
 
 	if ( mmPos == lastPos )
 	    break;
 
 	/*
 	  Update the slide table. This code has much in common with
 	  the initialization code.
 	*/
 	int sk = occ1[BadChar(mmIn[mmPos + minl])];
 	if ( sk == NoOccurrence ) {
 	    mmSlideTab[slideNext] = minl;
 	} else if ( sk > 0 ) {
 	    int k = slideNext + minl - sk;
 	    if ( k >= mmSlideTabSize )
 		k -= mmSlideTabSize;
 	    if ( sk > mmSlideTab[k] )
 		mmSlideTab[k] = sk;
 	}
 	slideHead = slideNext;
 	mmPos++;
     }
     return FALSE;
 }
 #else
 bool QRegExpEngine::bruteMatch()
 {
     while ( mmPos <= mmLen ) {
 	if ( matchHere() )
 	    return TRUE;
 	mmPos++;
     }
     return FALSE;
 }
 #endif
 
 /*
   Here's the core of the engine. It tries to do a match here and now.
 */
 bool QRegExpEngine::matchHere()
 {
     int ncur = 1, nnext = 0;
     int i = 0, j, k, m;
     bool stop = FALSE;
 
     mmMatchLen = -1;
     mmMatchedLen = -1;
     mmCurStack[0] = InitialState;
 
 #ifndef QT_NO_REGEXP_CAPTURE
     if ( ncap > 0 ) {
 	for ( j = 0; j < ncap; j++ ) {
 	    mmCurCapBegin[j] = EmptyCapture;
 	    mmCurCapEnd[j] = EmptyCapture;
 	}
     }
 #endif
 
 #ifndef QT_NO_REGEXP_BACKREF
     int *zzZ = 0;
 
     while ( (ncur > 0 || !mmSleeping.isEmpty()) && i <= mmLen - mmPos &&
 	    !stop )
 #else
     while ( ncur > 0 && i <= mmLen - mmPos && !stop )
 #endif
     {
 	int ch = ( i < mmLen - mmPos ) ? mmIn[mmPos + i].unicode() : 0;
 	for ( j = 0; j < ncur; j++ ) {
 	    int cur = mmCurStack[j];
 	    State *scur = s[cur];
 	    QMemArray<int>& outs = scur->outs;
 	    for ( k = 0; k < (int) outs.size(); k++ ) {
 		int next = outs[k];
 		State *snext = s[next];
 		bool in = TRUE;
 #ifndef QT_NO_REGEXP_BACKREF
 		int needSomeSleep = 0;
 #endif
 
 		/*
 		  First, check if the anchors are anchored properly.
 		*/
 		if ( scur->anchors != 0 ) {
 		    int a = at( *scur->anchors, next );
 		    if ( a != 0 && !testAnchor(i, a, mmCurCapBegin + j * ncap) )
 			in = FALSE;
 		}
 		/*
 		  If indeed they are, check if the input character is
 		  correct for this transition.
 		*/
 		if ( in ) {
 		    m = snext->match;
 		    if ( (m & (CharClassBit | BackRefBit)) == 0 ) {
 			if ( cs )
 			    in = ( m == ch );
 			else
 			    in = ( QChar(m).lower() == QChar(ch).lower() );
 		    } else if ( next == FinalState ) {
 			mmMatchLen = i;
 			stop = mmMinimal;
 			in = TRUE;
 		    } else if ( (m & CharClassBit) != 0 ) {
 #ifndef QT_NO_REGEXP_CCLASS
 			const CharClass *cc = cl[m ^ CharClassBit];
 			if ( cs )
 			    in = cc->in( ch );
 			else if ( cc->negative() )
 			    in = cc->in( QChar(ch).lower() ) &&
 				 cc->in( QChar(ch).upper() );
 			else
 			    in = cc->in( QChar(ch).lower() ) ||
 				 cc->in( QChar(ch).upper() );
 #endif
 #ifndef QT_NO_REGEXP_BACKREF
 		    } else { /* ( (m & BackRefBit) != 0 ) */
 			int bref = m ^ BackRefBit;
 			int ell = j * ncap + ( bref - 1 );
 
 			in = bref <= ncap && mmCurCapBegin[ell] != EmptyCapture;
 			if ( in ) {
 			    if ( cs )
 				in = ( mmIn[mmPos + mmCurCapBegin[ell]]
 				       == QChar(ch) );
 			    else
 				in = ( mmIn[mmPos + mmCurCapBegin[ell]].lower()
 				       == QChar(ch).lower() );
 			}
 
 			if ( in ) {
 			    int delta;
 			    if ( mmCurCapEnd[ell] == EmptyCapture )
 				delta = i - mmCurCapBegin[ell];
 			    else
 				delta = mmCurCapEnd[ell] - mmCurCapBegin[ell];
 
 			    in = ( delta <= mmLen - (mmPos + i) );
 			    if ( in && delta > 1 ) {
 				int n = 1;
 				if ( cs ) {
 				    while ( n < delta ) {
 					if ( mmIn[mmPos +
 						  mmCurCapBegin[ell] + n] !=
 					     mmIn[mmPos + i + n] )
 					    break;
 					n++;
 				    }
 				} else {
 				    while ( n < delta ) {
 					QChar a = mmIn[mmPos +
 						       mmCurCapBegin[ell] + n];
 					QChar b = mmIn[mmPos + i + n];
 					if ( a.lower() != b.lower() )
 					    break;
 					n++;
 				    }
 				}
 				in = ( n == delta );
 				if ( in )
 				    needSomeSleep = delta - 1;
 			    }
 			}
 #endif
 		    }
 		}
 
 		/*
 		  We must now update our data structures.
 		*/
 		if ( in ) {
 #ifndef QT_NO_REGEXP_CAPTURE
 		    int *capBegin, *capEnd;
 #endif
 		    /*
 		      If the next state was not encountered yet, all
 		      is fine.
 		    */
 		    if ( (m = mmInNextStack[next]) == -1 ) {
 			m = nnext++;
 			mmNextStack[m] = next;
 			mmInNextStack[next] = m;
 #ifndef QT_NO_REGEXP_CAPTURE
 			capBegin = mmNextCapBegin + m * ncap;
 			capEnd = mmNextCapEnd + m * ncap;
 
 		    /*
 		      Otherwise, we'll first maintain captures in
 		      temporary arrays, and decide at the end whether
 		      it's best to keep the previous capture zones or
 		      the new ones.
 		    */
 		    } else {
 			capBegin = mmTempCapBegin;
 			capEnd = mmTempCapEnd;
 #endif
 		    }
 
 #ifndef QT_NO_REGEXP_CAPTURE
 		    /*
 		      Updating the capture zones is much of a task.
 		    */
 		    if ( ncap > 0 ) {
 			memcpy( capBegin, mmCurCapBegin + j * ncap,
 				ncap * sizeof(int) );
 			memcpy( capEnd, mmCurCapEnd + j * ncap,
 				ncap * sizeof(int) );
 			int c = scur->atom, n = snext->atom;
 			int p = -1, q = -1;
 			int cap;
 
 			/*
 			  Lemma 1. For any x in the range [0..nf), we
 			  have f[x].parent < x.
 
 			  Proof. By looking at startAtom(), it is
 			  clear that cf < nf holds all the time, and
 			  thus that f[nf].parent < nf.
 			*/
 
 			/*
 			  If we are reentering an atom, we empty all
 			  capture zones inside it.
 			*/
 			if ( scur->reenter != 0 &&
 			     (q = at(*scur->reenter, next)) != 0 ) {
 			    QBitArray b;
 			    b.fill( FALSE, nf );
 			    b.setBit( q, TRUE );
 			    for ( int ell = q + 1; ell < nf; ell++ ) {
 				if ( b.testBit(f[ell].parent) ) {
 				    b.setBit( ell, TRUE );
 				    cap = f[ell].capture;
 				    if ( cap >= 0 ) {
 					capBegin[cap] = EmptyCapture;
 					capEnd[cap] = EmptyCapture;
 				    }
 				}
 			    }
 			    p = f[q].parent;
 
 			/*
 			  Otherwise, close the capture zones we are
 			  leaving. We are leaving f[c].capture,
 			  f[f[c].parent].capture,
 			  f[f[f[c].parent].parent].capture, ...,
 			  until f[x].capture, with x such that
 			  f[x].parent is the youngest common ancestor
 			  for c and n.
 
 			  We go up along c's and n's ancestry until
 			  we find x.
 			*/
 			} else {
 			    p = c;
 			    q = n;
 			    while ( p != q ) {
 				if ( p > q ) {
 				    cap = f[p].capture;
 				    if ( cap >= 0 ) {
 					if ( capBegin[cap] == i ) {
 					    capBegin[cap] = EmptyCapture;
 					    capEnd[cap] = EmptyCapture;
 					} else {
 					    capEnd[cap] = i;
 					}
 				    }
 				    p = f[p].parent;
 				} else {
 				    q = f[q].parent;
 				}
 			    }
 			}
 
 			/*
 			  In any case, we now open the capture zones
 			  we are entering. We work upwards from n
 			  until we reach p (the parent of the atom we
 			  reenter or the youngest common ancestor).
 			*/
 			while ( n > p ) {
 			    cap = f[n].capture;
 			    if ( cap >= 0 ) {
 				capBegin[cap] = i;
 				capEnd[cap] = EmptyCapture;
 			    }
 			    n = f[n].parent;
 			}
 			/*
 			  If the next state was already in
 			  mmNextStack, we must choose carefully which
 			  capture zones we want to keep.
 			*/
 			if ( capBegin == mmTempCapBegin &&
 			     isBetterCapture(capBegin, capEnd,
 					     mmNextCapBegin + m * ncap,
 					     mmNextCapEnd + m * ncap) ) {
 			    memcpy( mmNextCapBegin + m * ncap, capBegin,
 				    ncap * sizeof(int) );
 			    memcpy( mmNextCapEnd + m * ncap, capEnd,
 				    ncap * sizeof(int) );
 			}
 		    }
 #ifndef QT_NO_REGEXP_BACKREF
 		    /*
 		      We are done with updating the capture zones.
 		      It's now time to put the next state to sleep,
 		      if it needs to, and to remove it from
 		      mmNextStack.
 		    */
 		    if ( needSomeSleep > 0 ) {
 			zzZ = new int[1 + 2 * ncap];
 			zzZ[0] = next;
 			if ( ncap > 0 ) {
 			    memcpy( zzZ + 1, capBegin, ncap * sizeof(int) );
 			    memcpy( zzZ + 1 + ncap, capEnd,
 				    ncap * sizeof(int) );
 			}
 			mmInNextStack[mmNextStack[--nnext]] = -1;
 			mmSleeping.insert( i + needSomeSleep, zzZ );
 		    }
 #endif
 #endif
 		}
 	    }
 	}
 #ifndef QT_NO_REGEXP_CAPTURE
 	/*
 	  If we reached the final state, hurray! Copy the captured
 	  zone.
 	*/
 	if ( ncap > 0 && (m = mmInNextStack[FinalState]) != -1 ) {
 	    memcpy( mmCapBegin, mmNextCapBegin + m * ncap, ncap * sizeof(int) );
 	    memcpy( mmCapEnd, mmNextCapEnd + m * ncap, ncap * sizeof(int) );
 	}
 #ifndef QT_NO_REGEXP_BACKREF
 	/*
 	  It's time to wake up the sleepers.
 	*/
 	if ( !mmSleeping.isEmpty() ) {
 	    while ( (zzZ = mmSleeping.take(i)) != 0 ) {
 		int next = zzZ[0];
 		int *capBegin = zzZ + 1;
 		int *capEnd = zzZ + 1 + ncap;
 		bool copyOver = TRUE;
 
 		if ( (m = mmInNextStack[zzZ[0]]) == -1 ) {
 		    m = nnext++;
 		    mmNextStack[m] = next;
 		    mmInNextStack[next] = m;
 		} else {
 		    copyOver = isBetterCapture( mmNextCapBegin + m * ncap,
 						mmNextCapEnd + m * ncap,
 						capBegin, capEnd );
 		}
 		if ( copyOver ) {
 		    memcpy( mmNextCapBegin + m * ncap, capBegin,
 			    ncap * sizeof(int) );
 		    memcpy( mmNextCapEnd + m * ncap, capEnd,
 			    ncap * sizeof(int) );
 		}
 		delete[] zzZ;
 	    }
 	}
 #endif
 #endif
 	for ( j = 0; j < nnext; j++ )
 	    mmInNextStack[mmNextStack[j]] = -1;
 
 	// avoid needless iteration that confuses mmMatchedLen
 	if ( nnext == 1 && mmNextStack[0] == FinalState
 #ifndef QT_NO_REGEXP_BACKREF
 	     && mmSleeping.isEmpty()
 #endif
 	     )
 	    stop = TRUE;
 
 	qSwap( mmCurStack, mmNextStack );
 #ifndef QT_NO_REGEXP_CAPTURE
 	qSwap( mmCurCapBegin, mmNextCapBegin );
 	qSwap( mmCurCapEnd, mmNextCapEnd );
 #endif
 	ncur = nnext;
 	nnext = 0;
 	i++;
     }
 
 #ifndef QT_NO_REGEXP_BACKREF
     /*
       If minimal matching is enabled, we might have some sleepers
       left.
     */
     while ( !mmSleeping.isEmpty() ) {
 	zzZ = mmSleeping.take( *QIntDictIterator<int>(mmSleeping) );
 	delete[] zzZ;
     }
 #endif
 
     mmMatchedLen = i - 1;
     return ( mmMatchLen >= 0 );
 }
 
 #ifndef QT_NO_REGEXP_CCLASS
 
 QRegExpEngine::CharClass::CharClass()
     : c( 0 ), n( FALSE )
 {
 #ifndef QT_NO_REGEXP_OPTIM
     occ1.fill( NoOccurrence, NumBadChars );
 #endif
 }
 
 QRegExpEngine::CharClass& QRegExpEngine::CharClass::operator=(
 	const CharClass& cc )
 {
     c = cc.c;
     r = cc.r.copy();
     n = cc.n;
 #ifndef QT_NO_REGEXP_OPTIM
     occ1 = cc.occ1;
 #endif
     return *this;
 }
 
 void QRegExpEngine::CharClass::clear()
 {
     c = 0;
     r.resize( 0 );
     n = FALSE;
 }
 
 void QRegExpEngine::CharClass::setNegative( bool negative )
 {
     n = negative;
 #ifndef QT_NO_REGEXP_OPTIM
     occ1.fill( 0, NumBadChars );
 #endif
 }
 
 void QRegExpEngine::CharClass::addCategories( int cats )
 {
     c |= cats;
 #ifndef QT_NO_REGEXP_OPTIM
     occ1.fill( 0, NumBadChars );
 #endif
 }
 
 void QRegExpEngine::CharClass::addRange( ushort from, ushort to )
 {
     if ( from > to )
 	qSwap( from, to );
     int m = r.size();
     r.resize( m + 1 );
     r[m].from = from;
     r[m].to = to;
 
 #ifndef QT_NO_REGEXP_OPTIM
     int i;
 
     if ( to - from < NumBadChars ) {
 	occ1.detach();
 	if ( from % NumBadChars <= to % NumBadChars ) {
 	    for ( i = from % NumBadChars; i <= to % NumBadChars; i++ )
 		occ1[i] = 0;
 	} else {
 	    for ( i = 0; i <= to % NumBadChars; i++ )
 		occ1[i] = 0;
 	    for ( i = from % NumBadChars; i < NumBadChars; i++ )
 		occ1[i] = 0;
 	}
     } else {
 	occ1.fill( 0, NumBadChars );
     }
 #endif
 }
 
 bool QRegExpEngine::CharClass::in( QChar ch ) const
 {
 #ifndef QT_NO_REGEXP_OPTIM
     if ( occ1[BadChar(ch)] == NoOccurrence )
 	return n;
 #endif
 
     if ( c != 0 && (c & (1 << (int) ch.category())) != 0 )
 	return !n;
     for ( int i = 0; i < (int) r.size(); i++ ) {
 	if ( ch.unicode() >= r[i].from && ch.unicode() <= r[i].to )
 	    return !n;
     }
     return n;
 }
 
 #if defined(QT_DEBUG)
 void QRegExpEngine::CharClass::dump() const
 {
     int i;
     qDebug( "    %stive character class", n ? "nega" : "posi" );
 #ifndef QT_NO_REGEXP_CCLASS
     if ( c != 0 )
 	qDebug( "      categories 0x%.8x", c );
 #endif
     for ( i = 0; i < (int) r.size(); i++ )
 	qDebug( "      0x%.4x through 0x%.4x", r[i].from, r[i].to );
 }
 #endif
 #endif
 
 QRegExpEngine::Box::Box( QRegExpEngine *engine )
     : eng( engine ), skipanchors( 0 )
 #ifndef QT_NO_REGEXP_OPTIM
       , earlyStart( 0 ), lateStart( 0 ), maxl( 0 )
 #endif
 {
 #ifndef QT_NO_REGEXP_OPTIM
     occ1.fill( NoOccurrence, NumBadChars );
 #endif
     minl = 0;
 }
 
 QRegExpEngine::Box& QRegExpEngine::Box::operator=( const Box& b )
 {
     eng = b.eng;
     ls = b.ls;
     rs = b.rs;
     lanchors = b.lanchors;
     ranchors = b.ranchors;
     skipanchors = b.skipanchors;
 #ifndef QT_NO_REGEXP_OPTIM
     earlyStart = b.earlyStart;
     lateStart = b.lateStart;
     str = b.str;
     leftStr = b.leftStr;
     rightStr = b.rightStr;
     maxl = b.maxl;
     occ1 = b.occ1;
 #endif
     minl = b.minl;
     return *this;
 }
 
 void QRegExpEngine::Box::set( QChar ch )
 {
     ls.resize( 1 );
     ls[0] = eng->createState( ch );
     rs = ls;
     rs.detach();
 #ifndef QT_NO_REGEXP_OPTIM
     str = ch;
     leftStr = ch;
     rightStr = ch;
     maxl = 1;
     occ1.detach();
     occ1[BadChar(ch)] = 0;
 #endif
     minl = 1;
 }
 
 void QRegExpEngine::Box::set( const CharClass& cc )
 {
     ls.resize( 1 );
     ls[0] = eng->createState( cc );
     rs = ls;
     rs.detach();
 #ifndef QT_NO_REGEXP_OPTIM
     maxl = 1;
     occ1 = cc.firstOccurrence();
 #endif
     minl = 1;
 }
 
 #ifndef QT_NO_REGEXP_BACKREF
 void QRegExpEngine::Box::set( int bref )
 {
     ls.resize( 1 );
     ls[0] = eng->createState( bref );
     rs = ls;
     rs.detach();
     if ( bref >= 1 && bref <= MaxBackRefs )
 	skipanchors = Anchor_BackRef0Empty << bref;
 #ifndef QT_NO_REGEXP_OPTIM
     maxl = InftyLen;
 #endif
     minl = 0;
 }
 #endif
 
 void QRegExpEngine::Box::cat( const Box& b )
 {
     eng->addCatTransitions( rs, b.ls );
     addAnchorsToEngine( b );
     if ( minl == 0 ) {
 	mergeInto( &lanchors, b.lanchors );
 	if ( skipanchors != 0 ) {
 	    for ( int i = 0; i < (int) b.ls.size(); i++ ) {
 		int a = eng->anchorConcatenation( at(lanchors, b.ls[i]),
 						  skipanchors );
 		lanchors.insert( b.ls[i], a );
 	    }
 	}
 	mergeInto( &ls, b.ls );
     }
     if ( b.minl == 0 ) {
 	mergeInto( &ranchors, b.ranchors );
 	if ( b.skipanchors != 0 ) {
 	    for ( int i = 0; i < (int) rs.size(); i++ ) {
 		int a = eng->anchorConcatenation( at(ranchors, rs[i]),
 						  b.skipanchors );
 		ranchors.insert( rs[i], a );
 	    }
 	}
 	mergeInto( &rs, b.rs );
     } else {
 	ranchors = b.ranchors;
 	rs = b.rs;
     }
 
 #ifndef QT_NO_REGEXP_OPTIM
     if ( maxl != InftyLen ) {
 	if ( rightStr.length() + b.leftStr.length() >
 	     QMAX(str.length(), b.str.length()) ) {
 	    earlyStart = minl - rightStr.length();
 	    lateStart = maxl - rightStr.length();
 	    str = rightStr + b.leftStr;
 	} else if ( b.str.length() > str.length() ) {
 	    earlyStart = minl + b.earlyStart;
 	    lateStart = maxl + b.lateStart;
 	    str = b.str;
 	}
     }
 
     if ( (int) leftStr.length() == maxl )
 	leftStr += b.leftStr;
     if ( (int) b.rightStr.length() == b.maxl )
 	rightStr += b.rightStr;
     else
 	rightStr = b.rightStr;
 
     if ( maxl == InftyLen || b.maxl == InftyLen )
 	maxl = InftyLen;
     else
 	maxl += b.maxl;
 
     occ1.detach();
     for ( int i = 0; i < NumBadChars; i++ ) {
 	if ( b.occ1[i] != NoOccurrence && minl + b.occ1[i] < occ1[i] )
 	    occ1[i] = minl + b.occ1[i];
     }
 #endif
 
     minl += b.minl;
     if ( minl == 0 )
 	skipanchors = eng->anchorConcatenation( skipanchors, b.skipanchors );
     else
 	skipanchors = 0;
 }
 
 void QRegExpEngine::Box::orx( const Box& b )
 {
     mergeInto( &ls, b.ls );
     mergeInto( &lanchors, b.lanchors );
     mergeInto( &rs, b.rs );
     mergeInto( &ranchors, b.ranchors );
 
     if ( b.minl == 0 ) {
 	if ( minl == 0 )
 	    skipanchors = eng->anchorAlternation( skipanchors, b.skipanchors );
 	else
 	    skipanchors = b.skipanchors;
     }
 
 #ifndef QT_NO_REGEXP_OPTIM
     occ1.detach();
     for ( int i = 0; i < NumBadChars; i++ ) {
 	if ( occ1[i] > b.occ1[i] )
 	    occ1[i] = b.occ1[i];
     }
     earlyStart = 0;
     lateStart = 0;
     str = QString();
     leftStr = QString();
     rightStr = QString();
     if ( b.maxl > maxl )
 	maxl = b.maxl;
 #endif
     if ( b.minl < minl )
 	minl = b.minl;
 }
 
 void QRegExpEngine::Box::plus( int atom )
 {
 #ifndef QT_NO_REGEXP_CAPTURE
     eng->addPlusTransitions( rs, ls, atom );
 #else
     Q_UNUSED( atom );
     eng->addCatTransitions( rs, ls );
 #endif
     addAnchorsToEngine( *this );
 #ifndef QT_NO_REGEXP_OPTIM
     maxl = InftyLen;
 #endif
 }
 
 void QRegExpEngine::Box::opt()
 {
 #ifndef QT_NO_REGEXP_OPTIM
     earlyStart = 0;
     lateStart = 0;
     str = QString();
     leftStr = QString();
     rightStr = QString();
 #endif
     skipanchors = 0;
     minl = 0;
 }
 
 void QRegExpEngine::Box::catAnchor( int a )
 {
     if ( a != 0 ) {
 	for ( int i = 0; i < (int) rs.size(); i++ ) {
 	    a = eng->anchorConcatenation( at(ranchors, rs[i]), a );
 	    ranchors.insert( rs[i], a );
 	}
 	if ( minl == 0 )
 	    skipanchors = eng->anchorConcatenation( skipanchors, a );
     }
 }
 
 #ifndef QT_NO_REGEXP_OPTIM
 void QRegExpEngine::Box::setupHeuristics()
 {
     eng->setupGoodStringHeuristic( earlyStart, lateStart, str );
 
     /*
       A regular expression such as 112|1 has occ1['2'] = 2 and minl =
       1 at this point. An entry of occ1 has to be at most minl or
       infinity for the rest of the algorithm to go well.
 
       We waited until here before normalizing these cases (instead of
       doing it in Box::orx()) because sometimes things improve by
       themselves. Consider for example (112|1)34.
     */
     for ( int i = 0; i < NumBadChars; i++ ) {
 	if ( occ1[i] != NoOccurrence && occ1[i] >= minl )
 	    occ1[i] = minl;
     }
     eng->setupBadCharHeuristic( minl, occ1 );
 
     eng->heuristicallyChooseHeuristic();
 }
 #endif
 
 #if defined(QT_DEBUG)
 void QRegExpEngine::Box::dump() const
 {
     int i;
     qDebug( "Box of at least %d character%s", minl, minl == 1 ? "" : "s" );
     qDebug( "  Left states:" );
     for ( i = 0; i < (int) ls.size(); i++ ) {
 	if ( at(lanchors, ls[i]) == 0 )
 	    qDebug( "    %d", ls[i] );
 	else
 	    qDebug( "    %d [anchors 0x%.8x]", ls[i], lanchors[ls[i]] );
     }
     qDebug( "  Right states:" );
     for ( i = 0; i < (int) rs.size(); i++ ) {
 	if ( at(ranchors, rs[i]) == 0 )
 	    qDebug( "    %d", rs[i] );
 	else
 	    qDebug( "    %d [anchors 0x%.8x]", rs[i], ranchors[rs[i]] );
     }
     qDebug( "  Skip anchors: 0x%.8x", skipanchors );
 }
 #endif
 
 void QRegExpEngine::Box::addAnchorsToEngine( const Box& to ) const
 {
     for ( int i = 0; i < (int) to.ls.size(); i++ ) {
 	for ( int j = 0; j < (int) rs.size(); j++ ) {
 	    int a = eng->anchorConcatenation( at(ranchors, rs[j]),
 					      at(to.lanchors, to.ls[i]) );
 	    eng->addAnchors( rs[j], to.ls[i], a );
 	}
     }
 }
 
 int QRegExpEngine::getChar()
 {
     return ( yyPos == yyLen ) ? EOS : yyIn[yyPos++].unicode();
 }
 
 int QRegExpEngine::getEscape()
 {
 #ifndef QT_NO_REGEXP_ESCAPE
     const char tab[] = "afnrtv"; // no b, as \b means word boundary
     const char backTab[] = "\a\f\n\r\t\v";
     ushort low;
     int i;
 #endif
     ushort val;
     int prevCh = yyCh;
 
     if ( prevCh == EOS ) {
 	error( RXERR_END );
 	return Tok_Char | '\\';
     }
     yyCh = getChar();
 #ifndef QT_NO_REGEXP_ESCAPE
     if ( (prevCh & ~0xff) == 0 ) {
 	const char *p = strchr( tab, prevCh );
 	if ( p != 0 )
 	    return Tok_Char | backTab[p - tab];
     }
 #endif
 
     switch ( prevCh ) {
 #ifndef QT_NO_REGEXP_ESCAPE
     case '0':
 	val = 0;
 	for ( i = 0; i < 3; i++ ) {
 	    if ( yyCh >= '0' && yyCh <= '7' )
 		val = ( val << 3 ) | ( yyCh - '0' );
 	    else
 		break;
 	    yyCh = getChar();
 	}
 	if ( (val & ~0377) != 0 )
 	    error( RXERR_OCTAL );
 	return Tok_Char | val;
 #endif
 #ifndef QT_NO_REGEXP_ESCAPE
     case 'B':
 	return Tok_NonWord;
 #endif
 #ifndef QT_NO_REGEXP_CCLASS
     case 'D':
 	// see QChar::isDigit()
 	yyCharClass->addCategories( 0x7fffffef );
 	return Tok_CharClass;
     case 'S':
 	// see QChar::isSpace()
 	yyCharClass->addCategories( 0x7ffff87f );
 	yyCharClass->addRange( 0x0000, 0x0008 );
 	yyCharClass->addRange( 0x000e, 0x001f );
 	yyCharClass->addRange( 0x007f, 0x009f );
 	return Tok_CharClass;
     case 'W':
 	// see QChar::isLetterOrNumber()
-	yyCharClass->addCategories( 0x7ff07f8f );
+	yyCharClass->addCategories( 0x7fe07f8f );
+	yyCharClass->addRange( 0x203f, 0x2040 );
+	yyCharClass->addSingleton( 0x2040 );
+	yyCharClass->addSingleton( 0x30fb );
+	yyCharClass->addRange( 0xfe33, 0xfe34 );
+	yyCharClass->addRange( 0xfe4d, 0xfe4f );
+	yyCharClass->addSingleton( 0xff3f );
+	yyCharClass->addSingleton( 0xff65 );
 	return Tok_CharClass;
 #endif
 #ifndef QT_NO_REGEXP_ESCAPE
     case 'b':
 	return Tok_Word;
 #endif
 #ifndef QT_NO_REGEXP_CCLASS
     case 'd':
 	// see QChar::isDigit()
 	yyCharClass->addCategories( 0x00000010 );
 	return Tok_CharClass;
     case 's':
 	// see QChar::isSpace()
 	yyCharClass->addCategories( 0x00000380 );
 	yyCharClass->addRange( 0x0009, 0x000d );
 	return Tok_CharClass;
     case 'w':
 	// see QChar::isLetterOrNumber()
 	yyCharClass->addCategories( 0x000f8070 );
+	yyCharClass->addSingleton( 0x005f ); // '_'
 	return Tok_CharClass;
 #endif
 #ifndef QT_NO_REGEXP_ESCAPE
     case 'x':
 	val = 0;
 	for ( i = 0; i < 4; i++ ) {
 	    low = QChar( yyCh ).lower();
 	    if ( low >= '0' && low <= '9' )
 		val = ( val << 4 ) | ( low - '0' );
 	    else if ( low >= 'a' && low <= 'f' )
 		val = ( val << 4 ) | ( low - 'a' + 10 );
 	    else
 		break;
 	    yyCh = getChar();
 	}
 	return Tok_Char | val;
 #endif
     default:
 	if ( prevCh >= '1' && prevCh <= '9' ) {
 #ifndef QT_NO_REGEXP_BACKREF
 	    val = prevCh - '0';
 	    while ( yyCh >= '0' && yyCh <= '9' ) {
 		val = ( val *= 10 ) | ( yyCh - '0' );
 		yyCh = getChar();
 	    }
 	    return Tok_BackRef | val;
 #else
 	    error( RXERR_DISABLED );
 #endif
 	}
 	return Tok_Char | prevCh;
     }
 }
 
 #ifndef QT_NO_REGEXP_INTERVAL
 int QRegExpEngine::getRep( int def )
 {
     if ( yyCh >= '0' && yyCh <= '9' ) {
 	int rep = 0;
 	do {
 	    rep = 10 * rep + yyCh - '0';
 	    if ( rep >= InftyRep ) {
 		error( RXERR_REPETITION );
 		rep = def;
 	    }
 	    yyCh = getChar();
 	} while ( yyCh >= '0' && yyCh <= '9' );
 	return rep;
     } else {
 	return def;
     }
 }
 #endif
 
 #ifndef QT_NO_REGEXP_LOOKAHEAD
 void QRegExpEngine::skipChars( int n )
 {
     if ( n > 0 ) {
 	yyPos += n - 1;
 	yyCh = getChar();
     }
 }
 #endif
 
 void QRegExpEngine::error( const char *msg )
 {
     if ( yyError.isEmpty() )
 	yyError = QString::fromLatin1( msg );
 }
 
 void QRegExpEngine::startTokenizer( const QChar *rx, int len )
 {
     yyIn = rx;
     yyPos0 = 0;
     yyPos = 0;
     yyLen = len;
     yyCh = getChar();
     yyCharClass = new CharClass;
     yyMinRep = 0;
     yyMaxRep = 0;
     yyError = QString();
 }
 
 int QRegExpEngine::getToken()
 {
 #ifndef QT_NO_REGEXP_CCLASS
     ushort pendingCh = 0;
     bool charPending;
     bool rangePending;
     int tok;
 #endif
     int prevCh = yyCh;
 
     yyPos0 = yyPos - 1;
 #ifndef QT_NO_REGEXP_CCLASS
     yyCharClass->clear();
 #endif
     yyMinRep = 0;
     yyMaxRep = 0;
     yyCh = getChar();
     switch ( prevCh ) {
     case EOS:
 	yyPos0 = yyPos;
 	return Tok_Eos;
     case '$':
 	return Tok_Dollar;
     case '(':
 	if ( yyCh == '?' ) {
 	    prevCh = getChar();
 	    yyCh = getChar();
 	    switch ( prevCh ) {
 #ifndef QT_NO_REGEXP_LOOKAHEAD
 	    case '!':
 		return Tok_NegLookahead;
 	    case '=':
 		return Tok_PosLookahead;
 #endif
 	    case ':':
 		return Tok_MagicLeftParen;
 	    default:
 		error( RXERR_LOOKAHEAD );
 		return Tok_MagicLeftParen;
 	    }
 	} else {
 	    return Tok_LeftParen;
 	}
     case ')':
 	return Tok_RightParen;
     case '*':
 	yyMinRep = 0;
 	yyMaxRep = InftyRep;
 	return Tok_Quantifier;
     case '+':
 	yyMinRep = 1;
 	yyMaxRep = InftyRep;
 	return Tok_Quantifier;
     case '.':
 #ifndef QT_NO_REGEXP_CCLASS
 	yyCharClass->setNegative( TRUE );
 #endif
 	return Tok_CharClass;
     case '?':
 	yyMinRep = 0;
 	yyMaxRep = 1;
 	return Tok_Quantifier;
     case '[':
 #ifndef QT_NO_REGEXP_CCLASS
 	if ( yyCh == '^' ) {
 	    yyCharClass->setNegative( TRUE );
 	    yyCh = getChar();
 	}
 	charPending = FALSE;
 	rangePending = FALSE;
 	do {
 	    if ( yyCh == '-' && charPending && !rangePending ) {
 		rangePending = TRUE;
 		yyCh = getChar();
 	    } else {
 		if ( charPending && !rangePending ) {
 		    yyCharClass->addSingleton( pendingCh );
 		    charPending = FALSE;
 		}
 		if ( yyCh == '\\' ) {
 		    yyCh = getChar();
 		    tok = getEscape();
 		    if ( tok == Tok_Word )
 			tok = '\b';
 		} else {
 		    tok = Tok_Char | yyCh;
 		    yyCh = getChar();
 		}
 		if ( tok == Tok_CharClass ) {
 		    if ( rangePending ) {
 			yyCharClass->addSingleton( '-' );
 			yyCharClass->addSingleton( pendingCh );
 			charPending = FALSE;
 			rangePending = FALSE;
 		    }
 		} else if ( (tok & Tok_Char) != 0 ) {
 		    if ( rangePending ) {
 			yyCharClass->addRange( pendingCh, tok ^ Tok_Char );
 			charPending = FALSE;
 			rangePending = FALSE;
 		    } else {
 			pendingCh = tok ^ Tok_Char;
 			charPending = TRUE;
 		    }
 		} else {
 		    error( RXERR_CHARCLASS );
 		}
 	    }
 	}  while ( yyCh != ']' && yyCh != EOS );
 	if ( rangePending )
 	    yyCharClass->addSingleton( '-' );
 	if ( charPending )
 	    yyCharClass->addSingleton( pendingCh );
 	if ( yyCh == EOS )
 	    error( RXERR_END );
 	else
 	    yyCh = getChar();
 	return Tok_CharClass;
 #else
 	error( RXERR_END );
 	return Tok_Char | '[';
 #endif
     case '\\':
 	return getEscape();
     case ']':
 	error( RXERR_LEFTDELIM );
 	return Tok_Char | ']';
     case '^':
 	return Tok_Caret;
     case '{':
 #ifndef QT_NO_REGEXP_INTERVAL
 	yyMinRep = getRep( 0 );
 	yyMaxRep = yyMinRep;
 	if ( yyCh == ',' ) {
 	    yyCh = getChar();
 	    yyMaxRep = getRep( InftyRep );
 	}
 	if ( yyMaxRep < yyMinRep )
 	    qSwap( yyMinRep, yyMaxRep );
 	if ( yyCh != '}' )
 	    error( RXERR_REPETITION );
 	yyCh = getChar();
 	return Tok_Quantifier;
 #else
 	error( RXERR_DISABLED );
 	return Tok_Char | '{';
 #endif
     case '|':
 	return Tok_Bar;
     case '}':
 	error( RXERR_LEFTDELIM );
 	return Tok_Char | '}';
     default:
 	return Tok_Char | prevCh;
     }
 }
 
 int QRegExpEngine::parse( const QChar *pattern, int len )
 {
     valid = TRUE;
     startTokenizer( pattern, len );
     yyTok = getToken();
 #ifndef QT_NO_REGEXP_CAPTURE
     yyMayCapture = TRUE;
 #else
     yyMayCapture = FALSE;
 #endif
 
 #ifndef QT_NO_REGEXP_CAPTURE
     int atom = startAtom( FALSE );
 #endif
     CharClass anything;
     Box box( this ); // create InitialState
     box.set( anything );
     Box rightBox( this ); // create FinalState
     rightBox.set( anything );
 
     Box middleBox( this );
     parseExpression( &middleBox );
 #ifndef QT_NO_REGEXP_CAPTURE
     finishAtom( atom );
 #endif
 #ifndef QT_NO_REGEXP_OPTIM
     middleBox.setupHeuristics();
 #endif
     box.cat( middleBox );
     box.cat( rightBox );
     delete yyCharClass;
     yyCharClass = 0;
 
     officialncap = ncap;
 #ifndef QT_NO_REGEXP_BACKREF
     if ( nbrefs > ncap )
 	ncap = nbrefs;
 #endif
 
     mmCaptured.resize( 2 + 2 * officialncap );
     mmCapturedNoMatch.fill( -1, 2 + 2 * officialncap );
 
     /*
       We use one QMemArray<int> for all the big data used a lot in
       matchHere() and friends.
     */
 #ifndef QT_NO_REGEXP_OPTIM
     mmSlideTabSize = QMAX( minl + 1, 16 );
 #else
     mmSlideTabSize = 0;
 #endif
     mmBigArray.resize( (3 + 4 * ncap) * ns + 4 * ncap + mmSlideTabSize );
 
     mmInNextStack = mmBigArray.data();
     memset( mmInNextStack, -1, ns * sizeof(int) );
     mmCurStack = mmInNextStack + ns;
     mmNextStack = mmInNextStack + 2 * ns;
 
     mmCurCapBegin = mmInNextStack + 3 * ns;
     mmNextCapBegin = mmCurCapBegin + ncap * ns;
     mmCurCapEnd = mmCurCapBegin + 2 * ncap * ns;
     mmNextCapEnd = mmCurCapBegin + 3 * ncap * ns;
 
     mmTempCapBegin = mmCurCapBegin + 4 * ncap * ns;
     mmTempCapEnd = mmTempCapBegin + ncap;
     mmCapBegin = mmTempCapBegin + 2 * ncap;
     mmCapEnd = mmTempCapBegin + 3 * ncap;
 
     mmSlideTab = mmTempCapBegin + 4 * ncap;
 
     if ( !yyError.isEmpty() )
 	return -1;
 
 #ifndef QT_NO_REGEXP_OPTIM
     State *sinit = s[InitialState];
     caretAnchored = ( sinit->anchors != 0 );
     if ( caretAnchored ) {
 	QMap<int, int>& anchors = *sinit->anchors;
 	QMap<int, int>::ConstIterator a;
 	for ( a = anchors.begin(); a != anchors.end(); ++a ) {
 #ifndef QT_NO_REGEXP_ANCHOR_ALT
 	    if ( (*a & Anchor_Alternation) != 0 )
 		break;
 #endif
 	    if ( (*a & Anchor_Caret) == 0 ) {
 		caretAnchored = FALSE;
 		break;
 	    }
 	}
     }
 #endif
     return yyPos0;
 }
 
 void QRegExpEngine::parseAtom( Box *box )
 {
 #ifndef QT_NO_REGEXP_LOOKAHEAD
     QRegExpEngine *eng = 0;
     bool neg;
     int len;
 #endif
 
     switch ( yyTok ) {
     case Tok_Dollar:
 	box->catAnchor( Anchor_Dollar );
 	break;
     case Tok_Caret:
 	box->catAnchor( Anchor_Caret );
 	break;
 #ifndef QT_NO_REGEXP_LOOKAHEAD
     case Tok_PosLookahead:
     case Tok_NegLookahead:
 	neg = ( yyTok == Tok_NegLookahead );
 	eng = new QRegExpEngine( cs );
 	len = eng->parse( yyIn + yyPos - 1, yyLen - yyPos + 1 );
 	if ( len >= 0 )
 	    skipChars( len );
 	else
 	    error( RXERR_LOOKAHEAD );
 	box->catAnchor( addLookahead(eng, neg) );
 	yyTok = getToken();
 	if ( yyTok != Tok_RightParen )
 	    error( RXERR_LOOKAHEAD );
 	break;
 #endif
 #ifndef QT_NO_REGEXP_ESCAPE
     case Tok_Word:
 	box->catAnchor( Anchor_Word );
 	break;
     case Tok_NonWord:
 	box->catAnchor( Anchor_NonWord );
 	break;
 #endif
     case Tok_LeftParen:
     case Tok_MagicLeftParen:
 	yyTok = getToken();
 	parseExpression( box );
 	if ( yyTok != Tok_RightParen )
 	    error( RXERR_END );
 	break;
     case Tok_CharClass:
 	box->set( *yyCharClass );
 	break;
     case Tok_Quantifier:
 	error( RXERR_REPETITION );
 	break;
     default:
 	if ( (yyTok & Tok_Char) != 0 )
 	    box->set( QChar(yyTok ^ Tok_Char) );
 #ifndef QT_NO_REGEXP_BACKREF
 	else if ( (yyTok & Tok_BackRef) != 0 )
 	    box->set( yyTok ^ Tok_BackRef );
 #endif
 	else
 	    error( RXERR_DISABLED );
     }
     yyTok = getToken();
 }
 
 void QRegExpEngine::parseFactor( Box *box )
 {
 #ifndef QT_NO_REGEXP_CAPTURE
     int atom = startAtom( yyMayCapture && yyTok == Tok_LeftParen );
 #else
     static const int atom = 0;
 #endif
 
 #ifndef QT_NO_REGEXP_INTERVAL
 #define YYREDO() \
 	yyIn = in, yyPos0 = pos0, yyPos = pos, yyLen = len, yyCh = ch, \
 	*yyCharClass = charClass, yyMinRep = 0, yyMaxRep = 0, yyTok = tok
 
     const QChar *in = yyIn;
     int pos0 = yyPos0;
     int pos = yyPos;
     int len = yyLen;
     int ch = yyCh;
     CharClass charClass;
     if ( yyTok == Tok_CharClass )
 	charClass = *yyCharClass;
     int tok = yyTok;
     bool mayCapture = yyMayCapture;
 #endif
 
     parseAtom( box );
 #ifndef QT_NO_REGEXP_CAPTURE
     finishAtom( atom );
 #endif
 
     if ( yyTok == Tok_Quantifier ) {
 	if ( yyMaxRep == InftyRep ) {
 	    box->plus( atom );
 #ifndef QT_NO_REGEXP_INTERVAL
 	} else if ( yyMaxRep == 0 ) {
 	    box->clear();
 #endif
 	}
 	if ( yyMinRep == 0 )
 	    box->opt();
 
 #ifndef QT_NO_REGEXP_INTERVAL
 	yyMayCapture = FALSE;
 	int alpha = ( yyMinRep == 0 ) ? 0 : yyMinRep - 1;
 	int beta = ( yyMaxRep == InftyRep ) ? 0 : yyMaxRep - ( alpha + 1 );
 
 	Box rightBox( this );
 	int i;
 
 	for ( i = 0; i < beta; i++ ) {
 	    YYREDO();
 	    Box leftBox( this );
 	    parseAtom( &leftBox );
 	    leftBox.cat( rightBox );
 	    leftBox.opt();
 	    rightBox = leftBox;
 	}
 	for ( i = 0; i < alpha; i++ ) {
 	    YYREDO();
 	    Box leftBox( this );
 	    parseAtom( &leftBox );
 	    leftBox.cat( rightBox );
 	    rightBox = leftBox;
 	}
 	rightBox.cat( *box );
 	*box = rightBox;
 #endif
 	yyTok = getToken();
 #ifndef QT_NO_REGEXP_INTERVAL
 	yyMayCapture = mayCapture;
 #endif
     }
 #undef YYREDO
 }
 
 void QRegExpEngine::parseTerm( Box *box )
 {
 #ifndef QT_NO_REGEXP_OPTIM
     if ( yyTok != Tok_Eos && yyTok != Tok_RightParen && yyTok != Tok_Bar )
 	parseFactor( box );
 #endif
     while ( yyTok != Tok_Eos && yyTok != Tok_RightParen && yyTok != Tok_Bar ) {
 	Box rightBox( this );
 	parseFactor( &rightBox );
 	box->cat( rightBox );
     }
 }
 
 void QRegExpEngine::parseExpression( Box *box )
 {
     parseTerm( box );
     while ( yyTok == Tok_Bar ) {
 	Box rightBox( this );
 	yyTok = getToken();
 	parseTerm( &rightBox );
 	box->orx( rightBox );
     }
 }
 
 /*
   The struct QRegExpPrivate contains the private data of a regular
   expression other than the automaton. It makes it possible for many
   QRegExp objects to use the same QRegExpEngine object with different
   QRegExpPrivate objects.
 */
 struct QRegExpPrivate
 {
     QString pattern; // regular-expression or wildcard pattern
     QString rxpattern; // regular-expression pattern
 #ifndef QT_NO_REGEXP_WILDCARD
     bool wc; // wildcard mode?
 #endif
     bool min; // minimal matching? (instead of maximal)
 #ifndef QT_NO_REGEXP_CAPTURE
     QString t; // last string passed to QRegExp::search() or searchRev()
     QStringList capturedCache; // what QRegExp::capturedTexts() returned last
 #endif
     QMemArray<int> captured; // what QRegExpEngine::search() returned last
 
     QRegExpPrivate() { captured.fill( -1, 2 ); }
 };
 
 #ifndef QT_NO_REGEXP_OPTIM
 static QCache<QRegExpEngine> *engineCache = 0;
 static QSingleCleanupHandler<QCache<QRegExpEngine> > cleanup_cache;
 #endif
 
 static QRegExpEngine *newEngine( const QString& pattern, bool caseSensitive )
 {
 #ifndef QT_NO_REGEXP_OPTIM
     if ( engineCache != 0 ) {
 #ifdef QT_THREAD_SUPPORT
-	QMutexLocker locker( qt_global_mutexpool->get( &engineCache ) );
+	QMutexLocker locker( qt_global_mutexpool ?
+			     qt_global_mutexpool->get( &engineCache ) : 0 );
 #endif
 	QRegExpEngine *eng = engineCache->take( pattern );
 	if ( eng == 0 || eng->caseSensitive() != caseSensitive ) {
 	    delete eng;
 	} else {
 	    eng->ref();
 	    return eng;
 	}
     }
 #endif
     return new QRegExpEngine( pattern, caseSensitive );
 }
 
 static void derefEngine( QRegExpEngine *eng, const QString& pattern )
 {
-    if ( eng != 0 && eng->deref() ) {
-#ifndef QT_NO_REGEXP_OPTIM
 #ifdef QT_THREAD_SUPPORT
-	QMutexLocker locker( qt_global_mutexpool->get( &engineCache ) );
+    QMutexLocker locker( qt_global_mutexpool ?
+			 qt_global_mutexpool->get( &engineCache ) : 0 );
 #endif
+    if ( eng != 0 && eng->deref() ) {
+#ifndef QT_NO_REGEXP_OPTIM
 	if ( engineCache == 0 ) {
 	    engineCache = new QCache<QRegExpEngine>;
 	    engineCache->setAutoDelete( TRUE );
 	    cleanup_cache.set( &engineCache );
 	}
 	if ( !pattern.isNull() &&
 	     engineCache->insert(pattern, eng, 4 + pattern.length() / 4) )
 	    return;
 #else
 	Q_UNUSED( pattern );
 #endif
 	delete eng;
     }
 }
 
 /*!
     \enum QRegExp::CaretMode
 
     The CaretMode enum defines the different meanings of the caret
     (<b>^</b>) in a regular expression. The possible values are:
 
     \value CaretAtZero
 	   The caret corresponds to index 0 in the searched string.
 
     \value CaretAtOffset
 	   The caret corresponds to the start offset of the search.
 
     \value CaretWontMatch
 	   The caret never matches.
 */
 
 /*!
     Constructs an empty regexp.
 
     \sa isValid() errorString()
 */
 QRegExp::QRegExp()
 {
     eng = new QRegExpEngine( TRUE );
     priv = new QRegExpPrivate;
 #ifndef QT_NO_REGEXP_WILDCARD
     priv->wc = FALSE;
 #endif
     priv->min = FALSE;
     compile( TRUE );
 }
 
 /*!
     Constructs a regular expression object for the given \a pattern
     string. The pattern must be given using wildcard notation if \a
     wildcard is TRUE (default is FALSE). The pattern is case
     sensitive, unless \a caseSensitive is FALSE. Matching is greedy
     (maximal), but can be changed by calling setMinimal().
 
     \sa setPattern() setCaseSensitive() setWildcard() setMinimal()
 */
 QRegExp::QRegExp( const QString& pattern, bool caseSensitive, bool wildcard )
 {
     eng = 0;
     priv = new QRegExpPrivate;
     priv->pattern = pattern;
 #ifndef QT_NO_REGEXP_WILDCARD
     priv->wc = wildcard;
 #endif
     priv->min = FALSE;
     compile( caseSensitive );
 }
 
 /*!
     Constructs a regular expression as a copy of \a rx.
 
     \sa operator=()
 */
 QRegExp::QRegExp( const QRegExp& rx )
 {
     eng = 0;
     priv = new QRegExpPrivate;
     operator=( rx );
 }
 
 /*!
     Destroys the regular expression and cleans up its internal data.
 */
 QRegExp::~QRegExp()
 {
     derefEngine( eng, priv->rxpattern );
     delete priv;
 }
 
 /*!
     Copies the regular expression \a rx and returns a reference to the
     copy. The case sensitivity, wildcard and minimal matching options
     are also copied.
 */
 QRegExp& QRegExp::operator=( const QRegExp& rx )
 {
     rx.eng->ref();
     derefEngine( eng, priv->rxpattern );
     eng = rx.eng;
     priv->pattern = rx.priv->pattern;
     priv->rxpattern = rx.priv->rxpattern;
 #ifndef QT_NO_REGEXP_WILDCARD
     priv->wc = rx.priv->wc;
 #endif
     priv->min = rx.priv->min;
 #ifndef QT_NO_REGEXP_CAPTURE
     priv->t = rx.priv->t;
     priv->capturedCache = rx.priv->capturedCache;
 #endif
     priv->captured = rx.priv->captured;
     return *this;
 }
 
 /*!
     Returns TRUE if this regular expression is equal to \a rx;
     otherwise returns FALSE.
 
     Two QRegExp objects are equal if they have the same pattern
     strings and the same settings for case sensitivity, wildcard and
     minimal matching.
 */
 bool QRegExp::operator==( const QRegExp& rx ) const
 {
     return priv->pattern == rx.priv->pattern &&
 	   eng->caseSensitive() == rx.eng->caseSensitive() &&
 #ifndef QT_NO_REGEXP_WILDCARD
 	   priv->wc == rx.priv->wc &&
 #endif
 	   priv->min == rx.priv->min;
 }
 
 /*!
     \fn bool QRegExp::operator!=( const QRegExp& rx ) const
 
     Returns TRUE if this regular expression is not equal to \a rx;
     otherwise returns FALSE.
 
     \sa operator==()
 */
 
 /*!
     Returns TRUE if the pattern string is empty; otherwise returns
     FALSE.
 
     If you call exactMatch() with an empty pattern on an empty string
     it will return TRUE; otherwise it returns FALSE since it operates
     over the whole string. If you call search() with an empty pattern
     on \e any string it will return the start offset (0 by default)
     because the empty pattern matches the 'emptiness' at the start of
     the string. In this case the length of the match returned by
     matchedLength() will be 0.
 
     See QString::isEmpty().
 */
 
 bool QRegExp::isEmpty() const
 {
     return priv->pattern.isEmpty();
 }
 
 /*!
     Returns TRUE if the regular expression is valid; otherwise returns
     FALSE. An invalid regular expression never matches.
 
     The pattern <b>[a-z</b> is an example of an invalid pattern, since
     it lacks a closing square bracket.
 
     Note that the validity of a regexp may also depend on the setting
     of the wildcard flag, for example <b>*.html</b> is a valid
     wildcard regexp but an invalid full regexp.
 
     \sa errorString()
 */
 bool QRegExp::isValid() const
 {
     return eng->isValid();
 }
 
 /*!
     Returns the pattern string of the regular expression. The pattern
     has either regular expression syntax or wildcard syntax, depending
     on wildcard().
 
     \sa setPattern()
 */
 QString QRegExp::pattern() const
 {
     return priv->pattern;
 }
 
 /*!
     Sets the pattern string to \a pattern. The case sensitivity,
     wildcard and minimal matching options are not changed.
 
     \sa pattern()
 */
 void QRegExp::setPattern( const QString& pattern )
 {
     if ( priv->pattern != pattern ) {
 	priv->pattern = pattern;
 	compile( caseSensitive() );
     }
 }
 
 /*!
     Returns TRUE if case sensitivity is enabled; otherwise returns
     FALSE. The default is TRUE.
 
     \sa setCaseSensitive()
 */
 bool QRegExp::caseSensitive() const
 {
     return eng->caseSensitive();
 }
 
 /*!
     Sets case sensitive matching to \a sensitive.
 
     If \a sensitive is TRUE, <b>\\.txt$</b> matches \c{readme.txt} but
     not \c{README.TXT}.
 
     \sa caseSensitive()
 */
 void QRegExp::setCaseSensitive( bool sensitive )
 {
     if ( sensitive != eng->caseSensitive() )
 	compile( sensitive );
 }
 
 #ifndef QT_NO_REGEXP_WILDCARD
 /*!
     Returns TRUE if wildcard mode is enabled; otherwise returns FALSE.
     The default is FALSE.
 
     \sa setWildcard()
 */
 bool QRegExp::wildcard() const
 {
     return priv->wc;
 }
 
 /*!
     Sets the wildcard mode for the regular expression. The default is
     FALSE.
 
     Setting \a wildcard to TRUE enables simple shell-like wildcard
     matching. (See \link #wildcard-matching wildcard matching
     (globbing) \endlink.)
 
     For example, <b>r*.txt</b> matches the string \c{readme.txt} in
     wildcard mode, but does not match \c{readme}.
 
     \sa wildcard()
 */
 void QRegExp::setWildcard( bool wildcard )
 {
     if ( wildcard != priv->wc ) {
 	priv->wc = wildcard;
 	compile( caseSensitive() );
     }
 }
 #endif
 
 /*!
     Returns TRUE if minimal (non-greedy) matching is enabled;
     otherwise returns FALSE.
 
     \sa setMinimal()
 */
 bool QRegExp::minimal() const
 {
     return priv->min;
 }
 
 /*!
     Enables or disables minimal matching. If \a minimal is FALSE,
     matching is greedy (maximal) which is the default.
 
     For example, suppose we have the input string "We must be
     \<b>bold\</b>, very \<b>bold\</b>!" and the pattern
     <b>\<b>.*\</b></b>. With the default greedy (maximal) matching,
     the match is "We must be <u>\<b>bold\</b>, very
     \<b>bold\</b></u>!". But with minimal (non-greedy) matching the
     first match is: "We must be <u>\<b>bold\</b></u>, very
     \<b>bold\</b>!" and the second match is "We must be \<b>bold\</b>,
     very <u>\<b>bold\</b></u>!". In practice we might use the pattern
     <b>\<b>[^\<]+\</b></b> instead, although this will still fail for
     nested tags.
 
     \sa minimal()
 */
 void QRegExp::setMinimal( bool minimal )
 {
     priv->min = minimal;
 }
 
 /*!
     Returns TRUE if \a str is matched exactly by this regular
     expression; otherwise returns FALSE. You can determine how much of
     the string was matched by calling matchedLength().
 
     For a given regexp string, R, exactMatch("R") is the equivalent of
     search("^R$") since exactMatch() effectively encloses the regexp
     in the start of string and end of string anchors, except that it
     sets matchedLength() differently.
 
     For example, if the regular expression is <b>blue</b>, then
     exactMatch() returns TRUE only for input \c blue. For inputs \c
     bluebell, \c blutak and \c lightblue, exactMatch() returns FALSE
     and matchedLength() will return 4, 3 and 0 respectively.
 
     Although const, this function sets matchedLength(),
     capturedTexts() and pos().
 
     \sa search() searchRev() QRegExpValidator
 */
 bool QRegExp::exactMatch( const QString& str ) const
 {
 #ifndef QT_NO_REGEXP_CAPTURE
     priv->t = str;
     priv->capturedCache.clear();
 #endif
 
     priv->captured = eng->match( str, 0, priv->min, TRUE, 0 );
     if ( priv->captured[1] == (int) str.length() ) {
 	return TRUE;
     } else {
 	priv->captured.detach();
 	priv->captured[0] = 0;
 	priv->captured[1] = eng->matchedLength();
 	return FALSE;
     }
 }
 
 #ifndef QT_NO_COMPAT
 /*! \obsolete
 
   Attempts to match in \a str, starting from position \a index.
   Returns the position of the match, or -1 if there was no match.
 
   The length of the match is stored in \a *len, unless \a len is a
   null pointer.
 
   If \a indexIsStart is TRUE (the default), the position \a index in
   the string will match the start of string anchor, <b>^</b>, in the
   regexp, if present. Otherwise, position 0 in \a str will match.
 
   Use search() and matchedLength() instead of this function.
 
   \sa QString::mid() QConstString
 */
 int QRegExp::match( const QString& str, int index, int *len,
 		    bool indexIsStart ) const
 {
     int pos = search( str, index, indexIsStart ? CaretAtOffset : CaretAtZero );
     if ( len != 0 )
 	*len = matchedLength();
     return pos;
 }
 #endif // QT_NO_COMPAT
 
-/*!
-    \overload
-
-    This convenience function searches with a \c CaretMode of \c
-    CaretAtZero which is the most common usage.
-*/
-
 int QRegExp::search( const QString& str, int offset ) const
 {
     return search( str, offset, CaretAtZero );
 }
 
 /*!
     Attempts to find a match in \a str from position \a offset (0 by
     default). If \a offset is -1, the search starts at the last
     character; if -2, at the next to last character; etc.
 
     Returns the position of the first match, or -1 if there was no
     match.
 
     The \a caretMode parameter can be used to instruct whether <b>^</b>
     should match at index 0 or at \a offset.
 
     You might prefer to use QString::find(), QString::contains() or
     even QStringList::grep(). To replace matches use
     QString::replace().
 
     Example:
     \code
 	QString str = "offsets: 1.23 .50 71.00 6.00";
 	QRegExp rx( "\\d*\\.\\d+" );    // primitive floating point matching
 	int count = 0;
 	int pos = 0;
 	while ( (pos = rx.search(str, pos)) != -1 ) {
 	    count++;
 	    pos += rx.matchedLength();
 	}
 	// pos will be 9, 14, 18 and finally 24; count will end up as 4
     \endcode
 
     Although const, this function sets matchedLength(),
     capturedTexts() and pos().
 
     \sa searchRev() exactMatch()
 */
 
 int QRegExp::search( const QString& str, int offset, CaretMode caretMode ) const
 {
     if ( offset < 0 )
 	offset += str.length();
 #ifndef QT_NO_REGEXP_CAPTURE
     priv->t = str;
     priv->capturedCache.clear();
 #endif
     priv->captured = eng->match( str, offset, priv->min, FALSE,
 				 caretIndex(offset, caretMode) );
     return priv->captured[0];
 }
 
 
-/*!
-    \overload
-
-    This convenience function searches with a \c CaretMode of \c
-    CaretAtZero which is the most common usage.
-*/
-
 int QRegExp::searchRev( const QString& str, int offset ) const
 {
     return searchRev( str, offset, CaretAtZero );
 }
 
 /*!
     Attempts to find a match backwards in \a str from position \a
     offset. If \a offset is -1 (the default), the search starts at the
     last character; if -2, at the next to last character; etc.
 
     Returns the position of the first match, or -1 if there was no
     match.
 
     The \a caretMode parameter can be used to instruct whether <b>^</b>
     should match at index 0 or at \a offset.
 
     Although const, this function sets matchedLength(),
     capturedTexts() and pos().
 
     \warning Searching backwards is much slower than searching
     forwards.
 
     \sa search() exactMatch()
 */
 
 int QRegExp::searchRev( const QString& str, int offset,
 			CaretMode caretMode ) const
 {
     if ( offset < 0 )
 	offset += str.length();
 #ifndef QT_NO_REGEXP_CAPTURE
     priv->t = str;
     priv->capturedCache.clear();
 #endif
     if ( offset < 0 || offset > (int) str.length() ) {
 	priv->captured.detach();
 	priv->captured.fill( -1 );
 	return -1;
     }
 
     while ( offset >= 0 ) {
 	priv->captured = eng->match( str, offset, priv->min, TRUE,
 				     caretIndex(offset, caretMode) );
 	if ( priv->captured[0] == offset )
 	    return offset;
 	offset--;
     }
     return -1;
 }
 
 /*!
     Returns the length of the last matched string, or -1 if there was
     no match.
 
     \sa exactMatch() search() searchRev()
 */
 int QRegExp::matchedLength() const
 {
     return priv->captured[1];
 }
 
 #ifndef QT_NO_REGEXP_CAPTURE
-/*! 
+/*!
   Returns the number of captures contained in the regular expression.
  */
 int QRegExp::numCaptures() const
 {
     return eng->numCaptures();
 }
 
 
 
 /*!
     Returns a list of the captured text strings.
 
     The first string in the list is the entire matched string. Each
     subsequent list element contains a string that matched a
     (capturing) subexpression of the regexp.
 
     For example:
     \code
 	QRegExp rx( "(\\d+)(\\s*)(cm|inch(es)?)" );
 	int pos = rx.search( "Length: 36 inches" );
 	QStringList list = rx.capturedTexts();
 	// list is now ( "36 inches", "36", " ", "inches", "es" )
     \endcode
 
     The above example also captures elements that may be present but
     which we have no interest in. This problem can be solved by using
     non-capturing parentheses:
 
     \code
 	QRegExp rx( "(\\d+)(?:\\s*)(cm|inch(?:es)?)" );
 	int pos = rx.search( "Length: 36 inches" );
 	QStringList list = rx.capturedTexts();
 	// list is now ( "36 inches", "36", "inches" )
     \endcode
 
     Note that if you want to iterate over the list, you should iterate
     over a copy, e.g.
     \code
 	QStringList list = rx.capturedTexts();
 	QStringList::Iterator it = list.begin();
 	while( it != list.end() ) {
 	    myProcessing( *it );
 	    ++it;
 	}
     \endcode
 
     Some regexps can match an indeterminate number of times. For
     example if the input string is "Offsets: 12 14 99 231 7" and the
     regexp, \c{rx}, is <b>(\\d+)+</b>, we would hope to get a list of
     all the numbers matched. However, after calling
     \c{rx.search(str)}, capturedTexts() will return the list ( "12",
     "12" ), i.e. the entire match was "12" and the first subexpression
     matched was "12". The correct approach is to use cap() in a \link
     #cap_in_a_loop loop \endlink.
 
     The order of elements in the string list is as follows. The first
     element is the entire matching string. Each subsequent element
     corresponds to the next capturing open left parentheses. Thus
     capturedTexts()[1] is the text of the first capturing parentheses,
     capturedTexts()[2] is the text of the second and so on
     (corresponding to $1, $2, etc., in some other regexp languages).
 
     \sa cap() pos() exactMatch() search() searchRev()
 */
 QStringList QRegExp::capturedTexts()
 {
     if ( priv->capturedCache.isEmpty() ) {
 	for ( int i = 0; i < (int) priv->captured.size(); i += 2 ) {
 	    QString m;
 	    if ( priv->captured[i + 1] == 0 )
 		m = QString::fromLatin1( "" );
 	    else if ( priv->captured[i] >= 0 )
 		m = priv->t.mid( priv->captured[i],
 				 priv->captured[i + 1] );
 	    priv->capturedCache.append( m );
 	}
 	priv->t = QString::null;
     }
     return priv->capturedCache;
 }
 
 /*!
     Returns the text captured by the \a nth subexpression. The entire
     match has index 0 and the parenthesized subexpressions have
     indices starting from 1 (excluding non-capturing parentheses).
 
     \code
     QRegExp rxlen( "(\\d+)(?:\\s*)(cm|inch)" );
     int pos = rxlen.search( "Length: 189cm" );
     if ( pos > -1 ) {
 	QString value = rxlen.cap( 1 ); // "189"
 	QString unit = rxlen.cap( 2 );  // "cm"
 	// ...
     }
     \endcode
 
     The order of elements matched by cap() is as follows. The first
     element, cap(0), is the entire matching string. Each subsequent
     element corresponds to the next capturing open left parentheses.
     Thus cap(1) is the text of the first capturing parentheses, cap(2)
     is the text of the second, and so on.
 
     \target cap_in_a_loop
     Some patterns may lead to a number of matches which cannot be
     determined in advance, for example:
 
     \code
     QRegExp rx( "(\\d+)" );
     str = "Offsets: 12 14 99 231 7";
     QStringList list;
     pos = 0;
     while ( pos >= 0 ) {
 	pos = rx.search( str, pos );
 	if ( pos > -1 ) {
 	    list += rx.cap( 1 );
 	    pos  += rx.matchedLength();
 	}
     }
     // list contains "12", "14", "99", "231", "7"
     \endcode
 
     \sa capturedTexts() pos() exactMatch() search() searchRev()
 */
 QString QRegExp::cap( int nth )
 {
     if ( nth < 0 || nth >= (int) priv->captured.size() / 2 )
 	return QString::null;
     else
 	return capturedTexts()[nth];
 }
 
 /*!
     Returns the position of the \a nth captured text in the searched
     string. If \a nth is 0 (the default), pos() returns the position
     of the whole match.
 
     Example:
     \code
     QRegExp rx( "/([a-z]+)/([a-z]+)" );
     rx.search( "Output /dev/null" );    // returns 7 (position of /dev/null)
     rx.pos( 0 );                        // returns 7 (position of /dev/null)
     rx.pos( 1 );                        // returns 8 (position of dev)
     rx.pos( 2 );                        // returns 12 (position of null)
     \endcode
 
     For zero-length matches, pos() always returns -1. (For example, if
     cap(4) would return an empty string, pos(4) returns -1.) This is
     due to an implementation tradeoff.
 
     \sa capturedTexts() exactMatch() search() searchRev()
 */
 int QRegExp::pos( int nth )
 {
     if ( nth < 0 || nth >= (int) priv->captured.size() / 2 )
 	return -1;
     else
 	return priv->captured[2 * nth];
 }
 
 /*!
   Returns a text string that explains why a regexp pattern is
   invalid the case being; otherwise returns "no error occurred".
 
   \sa isValid()
 */
 QString QRegExp::errorString()
 {
     if ( isValid() ) {
 	return QString( RXERR_OK );
     } else {
 	return eng->errorString();
     }
 }
 #endif
 
 /*!
   Returns the string \a str with every regexp special character
   escaped with a backslash. The special characters are $, (, ), *, +,
   ., ?, [, \, ], ^, {, | and }.
 
   Example:
   \code
      s1 = QRegExp::escape( "bingo" );   // s1 == "bingo"
      s2 = QRegExp::escape( "f(x)" );    // s2 == "f\\(x\\)"
   \endcode
 
   This function is useful to construct regexp patterns dynamically:
 
   \code
     QRegExp rx( "(" + QRegExp::escape(name) +
 		"|" + QRegExp::escape(alias) + ")" );
   \endcode
 */
 QString QRegExp::escape( const QString& str )
 {
     static const char meta[] = "$()*+.?[\\]^{|}";
     QString quoted = str;
     int i = 0;
 
     while ( i < (int) quoted.length() ) {
 	if ( strchr(meta, quoted[i].latin1()) != 0 )
 	    quoted.insert( i++, "\\" );
 	i++;
     }
     return quoted;
 }
 
 void QRegExp::compile( bool caseSensitive )
 {
     derefEngine( eng, priv->rxpattern );
 #ifndef QT_NO_REGEXP_WILDCARD
     if ( priv->wc )
 	priv->rxpattern = wc2rx( priv->pattern );
     else
 #endif
 	priv->rxpattern = priv->pattern.isNull() ? QString::fromLatin1( "" )
 			  : priv->pattern;
     eng = newEngine( priv->rxpattern, caseSensitive );
 #ifndef QT_NO_REGEXP_CAPTURE
     priv->t = QString();
     priv->capturedCache.clear();
 #endif
     priv->captured.detach();
     priv->captured.fill( -1, 2 + 2 * eng->numCaptures() );
 }
 
 int QRegExp::caretIndex( int offset, CaretMode caretMode )
 {
     if ( caretMode == CaretAtZero ) {
 	return 0;
     } else if ( caretMode == CaretAtOffset ) {
 	return offset;
     } else { // CaretWontMatch
 	return -1;
     }
 }
 
 #endif // QT_NO_REGEXP
diff --git a/qmake/tools/qsemaphore_unix.cpp b/qmake/tools/qsemaphore_unix.cpp
index fcf28da..4516049 100644
--- a/qmake/tools/qsemaphore_unix.cpp
+++ b/qmake/tools/qsemaphore_unix.cpp
@@ -1,292 +1,290 @@
 /****************************************************************************
 ** $Id$
 **
 ** QSemaphore class for Unix
 **
 ** Created : 20010725
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #if defined(QT_THREAD_SUPPORT)
 
 #include "qsemaphore.h"
 #include "qmutex.h"
 #include "qwaitcondition.h"
 
 
 /*!
     \class QSemaphore qsemaphore.h
     \threadsafe
     \brief The QSemaphore class provides a robust integer semaphore.
 
     \ingroup thread
     \ingroup environment
 
     A QSemaphore can be used to serialize thread execution, in a
     similar way to a QMutex. A semaphore differs from a mutex, in
     that a semaphore can be accessed by more than one thread at a
     time.
 
     For example, suppose we have an application that stores data in a
     large tree structure. The application creates 10 threads
     (commonly called a thread pool) to perform searches on the tree.
     When the application searches the tree for some piece of data, it
     uses one thread per base node to do the searching. A semaphore
     could be used to make sure that two threads don't try to search
     the same branch of the tree at the same time.
 
     A non-computing example of a semaphore would be dining at a
     restuarant. A semaphore is initialized to have a maximum count
     equal to the number of chairs in the restuarant. As people
     arrive, they want a seat. As seats are filled, the semaphore is
     accessed, once per person. As people leave, the access is
     released, allowing more people to enter. If a party of 10 people
     want to be seated, but there are only 9 seats, those 10 people
     will wait, but a party of 4 people would be seated (taking the
     available seats to 5, making the party of 10 people wait longer).
 
     When a semaphore is created it is given a number which is the
     maximum number of concurrent accesses it will permit. This amount
     may be changed using operator++(), operator--(), operator+=() and
     operator-=(). The number of accesses allowed is retrieved with
     available(), and the total number with total(). Note that the
     incrementing functions will block if there aren't enough available
     accesses. Use tryAccess() if you want to acquire accesses without
     blocking.
 */
 
 
 class QSemaphorePrivate {
 public:
     QSemaphorePrivate(int);
 
     QMutex mutex;
     QWaitCondition cond;
 
     int value, max;
 };
 
 
 QSemaphorePrivate::QSemaphorePrivate(int m)
     : mutex(FALSE), value(0), max(m)
 {
 }
 
 
 /*!
     Creates a new semaphore. The semaphore can be concurrently
     accessed at most \a maxcount times.
 */
 QSemaphore::QSemaphore(int maxcount)
 {
     d = new QSemaphorePrivate(maxcount);
 }
 
 
 /*!
     Destroys the semaphore.
 
     \warning If you destroy a semaphore that has accesses in use the
     resultant behavior is undefined.
 */
 QSemaphore::~QSemaphore()
 {
     delete d;
 }
 
 
 /*!
     Postfix ++ operator.
 
     Try to get access to the semaphore. If \l available() == 0, this
     call will block until it can get access, i.e. until available() \>
     0.
 */
 int QSemaphore::operator++(int)
 {
     int ret;
 
     d->mutex.lock();
 
     while (d->value >= d->max)
 	d->cond.wait(&(d->mutex));
 
     ++(d->value);
     if (d->value > d->max) d->value = d->max;
     ret = d->value;
 
     d->mutex.unlock();
 
     return ret;
 }
 
 
 /*!
     Postfix -- operator.
 
     Release access of the semaphore. This wakes all threads waiting
     for access to the semaphore.
 */
 int QSemaphore::operator--(int)
 {
     int ret;
 
     d->mutex.lock();
 
     --(d->value);
     if (d->value < 0) d->value = 0;
     ret = d->value;
 
     d->cond.wakeAll();
     d->mutex.unlock();
 
     return ret;
 }
 
 
 /*!
     Try to get access to the semaphore. If \l available() \< \a n, this
     call will block until it can get all the accesses it wants, i.e.
     until available() \>= \a n.
 */
 int QSemaphore::operator+=(int n)
 {
     int ret;
 
     d->mutex.lock();
 
+    if ( n < 0 || n > d->max ) {
+#ifdef QT_CHECK_RANGE
+	qWarning( "QSemaphore::operator+=: paramter %d out of range", n );
+#endif // QT_CHECK_RANGE
+	n = n < 0 ? 0 : d->max;
+    }
+
     while (d->value + n > d->max)
 	d->cond.wait(&(d->mutex));
 
     d->value += n;
-
-#ifdef QT_CHECK_RANGE
-    if (d->value > d->max) {
-	qWarning("QSemaphore::operator+=: attempt to allocate more resources than available");
-	d->value = d->max;
-    }
-#endif
-
     ret = d->value;
 
     d->mutex.unlock();
 
     return ret;
 }
 
 
 /*!
     Release \a n accesses to the semaphore.
 */
 int QSemaphore::operator-=(int n)
 {
     int ret;
 
     d->mutex.lock();
 
-    d->value -= n;
-
+    if ( n < 0 || n > d->value ) {
 #ifdef QT_CHECK_RANGE
-    if (d->value < 0) {
-	qWarning("QSemaphore::operator-=: attempt to deallocate more resources than taken");
-	d->value = 0;
+	qWarning( "QSemaphore::operator-=: paramter %d out of range", n );
+#endif // QT_CHECK_RANGE
+	n = n < 0 ? 0 : d->value;
     }
-#endif
 
+    d->value -= n;
     ret = d->value;
 
     d->cond.wakeOne();
     d->mutex.unlock();
 
     return ret;
 }
 
 
 /*!
     Returns the number of accesses currently available to the
     semaphore.
 */
 int QSemaphore::available() const {
     int ret;
 
     d->mutex.lock();
     ret = d->max - d->value;
     d->mutex.unlock();
 
     return ret;
 }
 
 
 /*!
     Returns the total number of accesses to the semaphore.
 */
 int QSemaphore::total() const {
     int ret;
 
     d->mutex.lock();
     ret = d->max;
     d->mutex.unlock();
 
     return ret;
 }
 
 
 /*!
     Try to get access to the semaphore. If \l available() \< \a n, this
     function will return FALSE immediately. If \l available() \>= \a n,
     this function will take \a n accesses and return TRUE. This
     function does \e not block.
 */
 bool QSemaphore::tryAccess(int n)
 {
     if (! d->mutex.tryLock())
 	return FALSE;
 
     if (d->value + n > d->max) {
 	d->mutex.unlock();
 	return FALSE;
     }
 
     d->value += n;
 
 #ifdef QT_CHECK_RANGE
     if (d->value > d->max) {
 	qWarning("QSemaphore::operator+=: attempt to allocate more resources than available");
 	d->value = d->max;
     }
 #endif
 
     d->mutex.unlock();
 
     return TRUE;
 }
 
 #endif // QT_THREAD_SUPPORT
diff --git a/qmake/tools/qsettings.cpp b/qmake/tools/qsettings.cpp
index 5de105c..35fc039 100644
--- a/qmake/tools/qsettings.cpp
+++ b/qmake/tools/qsettings.cpp
@@ -1,1955 +1,2060 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QSettings class
 **
-** Created: 2000.06.26
+** Created : 000626
 **
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qplatformdefs.h"
 
 // POSIX Large File Support redefines open -> open64
 static inline int qt_open( const char *pathname, int flags, mode_t mode )
 { return ::open( pathname, flags, mode ); }
 #if defined(open)
 # undef open
 #endif
 
 // POSIX Large File Support redefines truncate -> truncate64
 #if defined(truncate)
 # undef truncate
 #endif
 
 #include "qsettings.h"
 
 #ifndef QT_NO_SETTINGS
 
 #include "qdir.h"
 #include "qfile.h"
 #include "qfileinfo.h"
 #include "qmap.h"
 #include "qtextstream.h"
 #include "qregexp.h"
 #include <private/qsettings_p.h>
 #include <errno.h>
 
 /*!
-  \class QSettings
-  \brief The QSettings class provides persistent platform-independent application settings.
-
-  \ingroup io
-  \ingroup misc
-  \mainclass
-
-  On Unix systems, QSettings uses text files to store settings. On Windows
-  systems, QSettings uses the system registry.  On Mac OS X, QSettings will
-  behave as on Unix, and store to text files.
-
-  Each setting comprises an identifying key and the data associated with
-  the key. A key is a unicode string which consists of \e two or more
-  subkeys. A subkey is a slash, '/', followed by one or more unicode
-  characters (excluding slashes, newlines, carriage returns and equals,
-  '=', signs). The associated data, called the entry or value, may be a
-  boolean, an integer, a double, a string or a list of strings. Entry
-  strings may contain any unicode characters.
-
-  If you want to save and restore the entire desktop's settings, i.e.
-  which applications are running, use QSettings to save the settings
-  for each individual application and QSessionManager to save the
-  desktop's session.
+    \class QSettings
+    \brief The QSettings class provides persistent platform-independent application settings.
+
+    \ingroup io
+    \ingroup misc
+    \mainclass
+
+    On Unix systems, QSettings uses text files to store settings. On Windows
+    systems, QSettings uses the system registry.  On Mac OS X, QSettings uses
+    the Carbon preferences API.
+
+    Each setting comprises an identifying key and the data associated with
+    the key. A key is a unicode string which consists of \e two or more
+    subkeys. A subkey is a slash, '/', followed by one or more unicode
+    characters (excluding slashes, newlines, carriage returns and equals,
+    '=', signs). The associated data, called the entry or value, may be a
+    boolean, an integer, a double, a string or a list of strings. Entry
+    strings may contain any unicode characters.
+
+    If you want to save and restore the entire desktop's settings, i.e.
+    which applications are running, use QSettings to save the settings
+    for each individual application and QSessionManager to save the
+    desktop's session.
 
     Example settings:
     \code
     /MyCompany/MyApplication/background color
     /MyCompany/MyApplication/foreground color
     /MyCompany/MyApplication/geometry/x
     /MyCompany/MyApplication/geometry/y
     /MyCompany/MyApplication/geometry/width
     /MyCompany/MyApplication/geometry/height
     /MyCompany/MyApplication/recent files/1
     /MyCompany/MyApplication/recent files/2
     /MyCompany/MyApplication/recent files/3
     \endcode
     Each line above is a complete key, made up of subkeys.
 
-    A typical usage pattern for application startup:
+    A typical usage pattern for reading application startup:
     \code
     QSettings settings;
-    settings.insertSearchPath( QSettings::Windows, "/MyCompany" );
-    // No search path needed for Unix; see notes further on.
-    // Use default values if the keys don't exist
-    QString bgColor = settings.readEntry( "/MyApplication/background color", "white" );
-    int width = settings.readNumEntry( "/MyApplication/geometry/width", 640 );
+    settings.setPath( "MyCompany.com", "MyApplication" );
+
+    QString bgColor = settings.readEntry( "/colors/background", "white" );
+    int width = settings.readNumEntry( "/geometry/width", 640 );
     // ...
     \endcode
 
     A typical usage pattern for application exit or 'save preferences':
     \code
     QSettings settings;
-    settings.insertSearchPath( QSettings::Windows, "/MyCompany" );
-    // No search path needed for Unix; see notes further on.
-    settings.writeEntry( "/MyApplication/background color", bgColor );
-    settings.writeEntry( "/MyApplication/geometry/width", width );
+    settings.setPath( "MyCompany.com", "MyApplication" );
+
+    settings.writeEntry( "/colors/background", bgColor );
+    settings.writeEntry( "/geometry/width", width );
     // ...
     \endcode
 
+    QSettings can build a key prefix that is prepended to all keys. To
+    build the key prefix, use beginGroup() and endGroup().
+    \code
+    QSettings settings;
+
+    settings.beginGroup( "/MainWindow" );
+	settings.beginGroup( "/Geometry" );
+	    int x = settings.readEntry( "/x" );
+	    // ...
+	settings.endGroup();
+	settings.beginGroup( "/Toolbars" );
+	    // ...
+	settings.endGroup();
+    settings.endGroup();
+    \endcode
+
     You can get a list of entry-holding keys by calling entryList(), and
     a list of key-holding keys using subkeyList().
 
     \code
     QStringList keys = entryList( "/MyApplication" );
     // keys contains 'background color' and 'foreground color'.
 
     QStringList keys = entryList( "/MyApplication/recent files" );
     // keys contains '1', '2' and '3'.
 
     QStringList subkeys = subkeyList( "/MyApplication" );
     // subkeys contains 'geometry' and 'recent files'
 
     QStringList subkeys = subkeyList( "/MyApplication/recent files" );
     // subkeys is empty.
     \endcode
 
-    If you wish to use a different search path call insertSearchPath()
-    as often as necessary to add your preferred paths. Call
-    removeSearchPath() to remove any unwanted paths.
-
     Since settings for Windows are stored in the registry there are size
     limits as follows:
     \list
     \i A subkey may not exceed 255 characters.
     \i An entry's value may not exceed 16,300 characters.
     \i All the values of a key (for example, all the 'recent files'
     subkeys values), may not exceed 65,535 characters.
     \endlist
 
-    These limitations are not enforced on Unix.
+    These limitations are not enforced on Unix or Mac OS X.
+
+    If you wish to use a different search path call insertSearchPath()
+    as often as necessary to add your preferred paths. Call
+    removeSearchPath() to remove any unwanted paths.
+
+    \section1 Notes for Mac OS X Applications
+
+    Internal to the CFPreferences API it is not defined (for Mac OS 9
+    support) where the settings will ultimitely be stored. However, at the
+    time of this writing the settings will be stored (either on a global or
+    user basis, preferring locally) into a plist file in
+    $ROOT/System/Library/Preferences (in XML format). QSettings will create
+    an appropriate plist file (com.<first group name>.plist) out of the
+    full path to a key.
+
+    For further information on CFPreferences see also
+    \link http://developer.apple.com/techpubs/macosx/CoreFoundation/PreferenceServices/preferenceservices_carbon.html
+    Apple's Specifications\endlink
 
     \section1 Notes for Unix Applications
 
     There is no universally accepted place for storing application
     settings under Unix. In the examples the settings file will be
     searched for in the following directories:
     \list 1
     \i INSTALL/etc/settings
     \i /opt/MyCompany/share/etc
     \i /opt/MyCompany/share/MyApplication/etc
     \i $HOME/.qt
     \endlist
     When reading settings the files are searched in the order shown
     above, with later settings overriding earlier settings. Files for
     which the user doesn't have read permission are ignored. When saving
     settings QSettings works in the order shown above, writing
     to the first settings file for which the user has write permission.
     (\c INSTALL is the directory where Qt was installed.  This can be
     modified by using the configure script's -prefix argument )
 
     If you want to put the settings in a particular place in the
     filesystem you could do this:
     \code
     settings.insertSearchPath( QSettings::Unix, "/opt/MyCompany/share" );
     \endcode
 
     But in practice you may prefer not to use a search path for Unix.
     For example the following code:
     \code
     settings.writeEntry( "/MyApplication/geometry/width", width );
     \endcode
     will end up writing the "geometry/width" setting to the file
     \c{$HOME/.qt/myapplicationrc} (assuming that the application is
     being run by an ordinary user, i.e. not by root).
 
     For cross-platform applications you should ensure that the Windows
     size limitations are not exceeded.
 */
 
 /*!
     \enum QSettings::System
 
     \value Mac Macintosh execution environments
     \value Unix Mac OS X, Unix, Linux and Unix-like execution environments
     \value Windows Windows execution environments
 */
 
 /*!
     \enum QSettings::Format
 
     \value Native Store the settings in a platform dependent location
     \value Ini Store the settings in a text file
 */
 
 /*!
     \enum QSettings::Scope
 
     \value Global Save settings as global as possible
     \value User Save settings in user space
 */
 
 #if defined(Q_OS_UNIX)
 typedef int HANDLE;
 #define Q_LOCKREAD F_RDLCK
 #define Q_LOCKWRITE F_WRLCK
 /*
   Locks the file specified by name.  The lockfile is created as a
   hidden file in the same directory as the target file, with .lock
   appended to the name. For example, "/etc/settings/onerc" uses a
   lockfile named "/etc/settings/.onerc.lock".  The type argument
   controls the type of the lock, it can be either F_RDLCK for a read
   lock, or F_WRLCK for a write lock.
 
   A file descriptor for the lock file is returned, and should be
   closed with closelock() when the lock is no longer needed.
  */
 static HANDLE openlock( const QString &name, int type )
 {
     QFileInfo info( name );
     // lockfile should be hidden, and never removed
     QString lockfile = info.dirPath() + "/." + info.fileName() + ".lock";
 
     // open the lockfile
     HANDLE fd = qt_open( QFile::encodeName( lockfile ),
 			 O_RDWR | O_CREAT, S_IRUSR | S_IWUSR );
 
     if ( fd < 0 ) {
  	// failed to open the lock file, most likely because of permissions
 	return fd;
     }
 
     struct flock fl;
     fl.l_type = type;
     fl.l_whence = SEEK_SET;
     fl.l_start = 0;
     fl.l_len = 0;
     if ( fcntl( fd, F_SETLKW, &fl ) == -1 ) {
 	// the lock failed, so we should fail silently, so that people
 	// using filesystems that do not support locking don't see
 	// numerous warnings about a failed lock
 	close( fd );
 	fd = -1;
     }
 
     return fd;
 }
 
 /*
   Closes the lock file specified by fd.  fd is the file descriptor
   returned by the openlock() function.
 */
 static void closelock( HANDLE fd )
 {
     if ( fd < 0 ) {
 	// the lock file is not open
 	return;
     }
 
     struct flock fl;
     fl.l_type = F_UNLCK;
     fl.l_whence = SEEK_SET;
     fl.l_start = 0;
     fl.l_len = 0;
     // ignore the return value, so that the unlock fails silently
     (void) fcntl( fd, F_SETLKW, &fl );
 
     close( fd );
 }
 #elif defined(Q_WS_WIN)
 #define Q_LOCKREAD 1
 #define Q_LOCKWRITE 2
 
 static HANDLE openlock( const QString &name, int /*type*/ )
 {
     if ( !QFile::exists( name ) )
 	return 0;
 
     return 0;
 
     HANDLE fd = 0;
 
     QT_WA( {
 	fd = CreateFileW( (TCHAR*)name.ucs2(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
     } , {
 	fd = CreateFileA( name.local8Bit(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
     } );
 
-    if ( !LockFile( fd, 0, 0, -1, -1 ) ) {
+    if ( !LockFile( fd, 0, 0, (DWORD)-1, (DWORD)-1 ) ) { // ### (DWORD)-1 ???
 #ifdef QT_CHECK_STATE
 	qWarning( "QSettings: openlock failed!" );
 #endif
     }
     return fd;
 }
 
-void closelock( HANDLE fd )
+static void closelock( HANDLE fd )
 {
     if ( !fd )
 	return;
 
-    if ( !UnlockFile( fd, 0, 0, -1, -1 ) ) {
+    if ( !UnlockFile( fd, 0, 0, (DWORD)-1, (DWORD)-1 ) ) { // ### (DWORD)-1 ???
 #ifdef QT_CHECK_STATE
 	qWarning( "QSettings: closelock failed!");
 #endif
     }
     CloseHandle( fd );
 }
 #endif
 
 
 QSettingsGroup::QSettingsGroup()
     : modified(FALSE)
 {
 }
 
 
 
 
 void QSettingsHeading::read(const QString &filename)
 {
     if (! QFileInfo(filename).exists())
 	return;
 
     HANDLE lockfd = openlock( filename, Q_LOCKREAD );
 
     QFile file(filename);
     if (! file.open(IO_ReadOnly)) {
 #if defined(QT_CHECK_STATE)
 	qWarning("QSettings: failed to open file '%s'", filename.latin1());
 #endif
 	return;
     }
 
     git = end();
 
     QTextStream stream(&file);
     stream.setEncoding(QTextStream::UnicodeUTF8);
     while (! stream.atEnd())
 	parseLine(stream);
 
     git = end();
 
     file.close();
 
     closelock( lockfd );
 }
 
 
 void QSettingsHeading::parseLine(QTextStream &stream)
 {
     QString line = stream.readLine();
     if (line.isEmpty())
 	// empty line... we'll allow it
 	return;
 
     if (line[0] == QChar('#'))
 	// commented line
 	return;
 
     if (line[0] == QChar('[')) {
 	QString gname = line;
 
 	gname = gname.remove(0, 1);
 	if (gname[(int)gname.length() - 1] == QChar(']'))
 	    gname = gname.remove(gname.length() - 1, 1);
 
 	git = find(gname);
 	if (git == end())
 	    git = replace(gname, QSettingsGroup());
     } else {
 	if (git == end()) {
 #if defined(QT_CHECK_STATE)
 	    qWarning("QSettings: line '%s' out of group", line.latin1());
 #endif
 	    return;
 	}
 
 	int i = line.find('=');
        	if (i == -1) {
 #if defined(QT_CHECK_STATE)
 	    qWarning("QSettings: malformed line '%s' in group '%s'",
 		     line.latin1(), git.key().latin1());
 #endif
 	    return;
 	} else {
 	    QString key, value;
 	    key = line.left(i);
 	    value = "";
 	    bool esc=TRUE;
 	    i++;
 	    while (esc) {
 		esc = FALSE;
 		for ( ; i < (int)line.length(); i++ ) {
 		    if ( esc ) {
 			if ( line[i] == 'n' )
 			    value.append('\n'); // escaped newline
 			else if ( line[i] == '0' )
 			    value = QString::null; // escaped empty string
 			else
 			    value.append(line[i]);
 			esc = FALSE;
 		    } else if ( line[i] == '\\' )
 			esc = TRUE;
 		    else
 			value.append(line[i]);
 		}
 		if ( esc ) {
 		    // Backwards-compatiblity...
 		    // still escaped at EOL - manually escaped "newline"
 		    if (stream.atEnd()) {
 #if defined(QT_CHECK_STATE)
 			qWarning("QSettings: reached end of file, expected continued line");
 #endif
 			break;
 		    }
 		    value.append('\n');
 		    line = stream.readLine();
 		    i = 0;
 		}
 	    }
 
 	    (*git).insert(key, value);
 	}
     }
 }
 
 #ifdef Q_WS_WIN // for homedirpath reading from registry
 #include "qt_windows.h"
 #include "qlibrary.h"
 
 #ifndef CSIDL_APPDATA
 #define CSIDL_APPDATA                   0x001a        // <user name>\Application Data
 #endif
 #ifndef CSIDL_COMMON_APPDATA
 #define CSIDL_COMMON_APPDATA            0x0023        // All Users\Application Data
 #endif
 
 #endif
 
 QSettingsPrivate::QSettingsPrivate( QSettings::Format format )
     : groupDirty( TRUE ), modified(FALSE), globalScope(TRUE)
 {
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( format != QSettings::Ini )
 	return;
+#else
+    Q_UNUSED( format );
 #endif
 
     QString appSettings(QDir::homeDirPath() + "/.qt/");
     QString defPath;
 #ifdef Q_WS_WIN
 #ifdef Q_OS_TEMP
 	TCHAR path[MAX_PATH];
 	SHGetSpecialFolderPath( 0, path, CSIDL_APPDATA, FALSE );
 	appSettings  = QString::fromUcs2( path );
 	SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE );
 	defPath = QString::fromUcs2( path );
 #else
     QLibrary library( "shell32" );
     library.setAutoUnload( FALSE );
     QT_WA( {
 	typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, LPTSTR, int, BOOL);
 	GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve( "SHGetSpecialFolderPathW" );
 	if ( SHGetSpecialFolderPath ) {
 	    TCHAR path[MAX_PATH];
 	    SHGetSpecialFolderPath( 0, path, CSIDL_APPDATA, FALSE );
 	    appSettings  = QString::fromUcs2( (ushort*)path );
 	    SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE );
 	    defPath = QString::fromUcs2( (ushort*)path );
 	}
     } , {
 	typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, char*, int, BOOL);
 	GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve( "SHGetSpecialFolderPathA" );
 	if ( SHGetSpecialFolderPath ) {
 	    char path[MAX_PATH];
 	    SHGetSpecialFolderPath( 0, path, CSIDL_APPDATA, FALSE );
 	    appSettings = QString::fromLocal8Bit( path );
 	    SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE );
 	    defPath = QString::fromLocal8Bit( path );
 	}
     } );
 #endif // Q_OS_TEMP
 #else
 // for now
 #define QSETTINGS_DEFAULT_PATH_SUFFIX "/etc/settings"
 
     defPath = qInstallPath();
     defPath += QSETTINGS_DEFAULT_PATH_SUFFIX;
 #endif
     QDir dir(appSettings);
     if (! dir.exists()) {
 	if (! dir.mkdir(dir.path()))
 #if defined(QT_CHECK_STATE)
 	    qWarning("QSettings: error creating %s", dir.path().latin1());
+#else
+	    ;
 #endif
     }
 
     if ( !!defPath )
 	searchPaths.append(defPath);
     searchPaths.append(dir.path());
 }
 
 QSettingsPrivate::~QSettingsPrivate()
 {
 }
 
 QSettingsGroup QSettingsPrivate::readGroup()
 {
     QSettingsHeading hd;
     QSettingsGroup grp;
 
     QMap<QString,QSettingsHeading>::Iterator headingsit = headings.find(heading);
     if (headingsit != headings.end())
 	hd = *headingsit;
 
     QSettingsHeading::Iterator grpit = hd.find(group);
     if (grpit == hd.end()) {
 	QStringList::Iterator it = searchPaths.begin();
+	if ( !globalScope )
+	    ++it;
 	while (it != searchPaths.end()) {
 	    QString filebase = heading.lower().replace(QRegExp("\\s+"), "_");
 	    QString fn((*it++) + "/" + filebase + "rc");
 	    if (! hd.contains(fn + "cached")) {
 		hd.read(fn);
 		hd.insert(fn + "cached", QSettingsGroup());
 	    }
 	}
 
 	headings.replace(heading, hd);
 
 	grpit = hd.find(group);
 	if (grpit != hd.end())
 	    grp = *grpit;
     } else if (hd.count() != 0)
 	grp = *grpit;
 
     return grp;
 }
 
 
 void QSettingsPrivate::removeGroup(const QString &key)
 {
     QSettingsHeading hd;
     QSettingsGroup grp;
     bool found = FALSE;
 
     QMap<QString,QSettingsHeading>::Iterator headingsit = headings.find(heading);
     if (headingsit != headings.end())
 	hd = *headingsit;
 
     QSettingsHeading::Iterator grpit = hd.find(group);
     if (grpit == hd.end()) {
 	QStringList::Iterator it = searchPaths.begin();
+	if ( !globalScope )
+	    ++it;
 	while (it != searchPaths.end()) {
 	    QString filebase = heading.lower().replace(QRegExp("\\s+"), "_");
 	    QString fn((*it++) + "/" + filebase + "rc");
 	    if (! hd.contains(fn + "cached")) {
 		hd.read(fn);
 		hd.insert(fn + "cached", QSettingsGroup());
 	    }
 	}
 
 	headings.replace(heading, hd);
 
 	grpit = hd.find(group);
 	if (grpit != hd.end()) {
 	    found = TRUE;
 	    grp = *grpit;
 	}
     } else if (hd.count() != 0) {
 	found = TRUE;
 	grp = *grpit;
     }
 
     if (found) {
 	grp.remove(key);
 
 	if (grp.count() > 0)
 	    hd.replace(group, grp);
 	else
 	    hd.remove(group);
 
 	if (hd.count() > 0)
 	    headings.replace(heading, hd);
 	else
 	    headings.remove(heading);
 
 	modified = TRUE;
     }
 }
 
 
 void QSettingsPrivate::writeGroup(const QString &key, const QString &value)
 {
     QSettingsHeading hd;
     QSettingsGroup grp;
 
     QMap<QString,QSettingsHeading>::Iterator headingsit = headings.find(heading);
     if (headingsit != headings.end())
 	hd = *headingsit;
 
     QSettingsHeading::Iterator grpit = hd.find(group);
     if (grpit == hd.end()) {
 	QStringList::Iterator it = searchPaths.begin();
+	if ( !globalScope )
+	    ++it;
 	while (it != searchPaths.end()) {
 	    QString filebase = heading.lower().replace(QRegExp("\\s+"), "_");
 	    QString fn((*it++) + "/" + filebase + "rc");
 	    if (! hd.contains(fn + "cached")) {
 		hd.read(fn);
 		hd.insert(fn + "cached", QSettingsGroup());
 	    }
 	}
 
 	headings.replace(heading, hd);
 
 	grpit = hd.find(group);
 	if (grpit != hd.end())
 	    grp = *grpit;
     } else if (hd.count() != 0)
 	grp = *grpit;
 
     grp.modified = TRUE;
     grp.replace(key, value);
     hd.replace(group, grp);
     headings.replace(heading, hd);
 
     modified = TRUE;
 }
 
 
 QDateTime QSettingsPrivate::modificationTime()
 {
     QSettingsHeading hd = headings[heading];
     QSettingsGroup grp = hd[group];
 
     QDateTime datetime;
 
     QStringList::Iterator it = searchPaths.begin();
+    if ( !globalScope )
+	++it;
     while (it != searchPaths.end()) {
 	QFileInfo fi((*it++) + "/" + heading + "rc");
 	if (fi.exists() && fi.lastModified() > datetime)
 	    datetime = fi.lastModified();
     }
 
     return datetime;
 }
 
-static bool verifyKey( const QString &key )
+bool qt_verify_key( const QString &key )
 {
     if ( key.isEmpty() || key[0] != '/' || key.contains( QRegExp("[=\\\\r\\\\n" ) ) )
 	return FALSE;
     return TRUE;
 }
 
 static inline QString groupKey( const QString &group, const QString &key )
 {
-    if ( group.endsWith( "/" ) || key.startsWith( "/" ) )
+    if ( group.isEmpty() || ( group.length() == 1 && group[0] == '/' ) ) {
+	// group is empty, or it contains a single '/', so we just return the key
+	if ( key.startsWith( "/" ) )
+	    return key;
+	return "/" + key;
+    } else if ( group.endsWith( "/" ) || key.startsWith( "/" ) ) {
 	return group + key;
+    }
     return group + "/" + key;
 }
 
 /*!
   Inserts \a path into the settings search path. The semantics of \a
   path depends on the system \a s.
 
   When \a s is \e Windows and the execution environment is \e not
   Windows the function does nothing. Similarly when \a s is \e Unix and
   the execution environment is \e not Unix the function does nothing.
 
   When \a s is \e Windows, and the execution environment is Windows, the
   search path list will be used as the first subfolder of the "Software"
   folder in the registry.
 
   When reading settings the folders are searched forwards from the
   first folder (listed below) to the last, returning the first
-  settings found, and ignoring any folders for which the user doesn't 
+  settings found, and ignoring any folders for which the user doesn't
   have read permission.
   \list 1
   \i HKEY_CURRENT_USER/Software/MyCompany/MyApplication
   \i HKEY_LOCAL_MACHINE/Software/MyCompany/MyApplication
   \i HKEY_CURRENT_USER/Software/MyApplication
   \i HKEY_LOCAL_MACHINE/Software/MyApplication
   \endlist
 
   \code
   QSettings settings;
   settings.insertSearchPath( QSettings::Windows, "/MyCompany" );
   settings.writeEntry( "/MyApplication/Tip of the day", TRUE );
   \endcode
   The code above will write the subkey "Tip of the day" into the \e
   first of the registry folders listed below that is found and for
   which the user has write permission.
   \list 1
   \i HKEY_LOCAL_MACHINE/Software/MyCompany/MyApplication
   \i HKEY_CURRENT_USER/Software/MyCompany/MyApplication
   \i HKEY_LOCAL_MACHINE/Software/MyApplication
   \i HKEY_CURRENT_USER/Software/MyApplication
   \endlist
   If a setting is found in the HKEY_CURRENT_USER space, this setting
-  is overwritten independently of write permissions in the 
+  is overwritten independently of write permissions in the
   HKEY_LOCAL_MACHINE space.
 
   When \a s is \e Unix, and the execution environment is Unix, the
   search path list will be used when trying to determine a suitable
   filename for reading and writing settings files. By default, there are
   two entries in the search path:
 
   \list 1
   \i INSTALL/etc - where \c INSTALL is the directory where Qt was installed.
   \i $HOME/.qt/ - where \c $HOME is the user's home directory.
   \endlist
 
   All insertions into the search path will go before $HOME/.qt/.
   For example:
   \code
   QSettings settings;
   settings.insertSearchPath( QSettings::Unix, "/opt/MyCompany/share/etc" );
   settings.insertSearchPath( QSettings::Unix, "/opt/MyCompany/share/MyApplication/etc" );
   // ...
   \endcode
   Will result in a search path of:
   \list 1
   \i INSTALL/etc
   \i /opt/MyCompany/share/etc
   \i /opt/MyCompany/share/MyApplication/etc
   \i $HOME/.qt
   \endlist
     When reading settings the files are searched in the order shown
     above, with later settings overriding earlier settings. Files for
     which the user doesn't have read permission are ignored. When saving
     settings QSettings works in the order shown above, writing
     to the first settings file for which the user has write permission.
 
   Settings under Unix are stored in files whose names are based on the
   first subkey of the key (not including the search path). The algorithm
   for creating names is essentially: lowercase the first subkey, replace
   spaces with underscores and add 'rc', e.g.
   <tt>/MyCompany/MyApplication/background color</tt> will be stored in
   <tt>myapplicationrc</tt> (assuming that <tt>/MyCompany</tt> is part of
   the search path).
 
   \sa removeSearchPath()
 
 */
 void QSettings::insertSearchPath( System s, const QString &path)
 {
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd ) {
 	d->sysInsertSearchPath( s, path );
 	return;
     }
 #endif
 
-    if ( !verifyKey( path ) ) {
+#if !defined(Q_WS_WIN)
+    if ( s == Windows )
+	return;
+#endif
+#if !defined(Q_WS_WIN)
+    if ( s == Mac )
+	return;
+#endif
+
+    if ( !qt_verify_key( path ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::insertSearchPath: Invalid key: '%s'", path.isNull() ? "(null)" : path.latin1() );
 #endif
 	return;
     }
 
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd && s != Unix ) {
 #else
     if ( s != Unix ) {
 #endif
-#ifdef Q_OS_MAC
+#if !defined(QWS) && defined(Q_OS_MAC)
 	if(s != Mac) //mac is respected on the mac as well
 #endif
 	    return;
     }
 
+    QString realPath = path;
+#if defined(Q_WS_WIN)
+    QString defPath = d->globalScope ? d->searchPaths.first() : d->searchPaths.last();
+    realPath = defPath + path;
+#endif
+
     QStringList::Iterator it = d->searchPaths.find(d->searchPaths.last());
     if (it != d->searchPaths.end()) {
-	d->searchPaths.insert(it, path);
+	d->searchPaths.insert(it, realPath);
     }
 }
 
 
 /*!
   Removes all occurrences of \a path (using exact matching) from the
   settings search path for system \a s. Note that the default search
   paths cannot be removed.
 
   \sa insertSearchPath()
 */
 void QSettings::removeSearchPath( System s, const QString &path)
 {
-    if ( !verifyKey( path ) ) {
+    if ( !qt_verify_key( path ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::insertSearchPath: Invalid key: '%s'", path.isNull() ? "(null)" : path.latin1() );
 #endif
 	return;
     }
 
 #ifdef Q_WS_WIN
     if ( d->sysd ) {
 	d->sysRemoveSearchPath( s, path );
 	return;
     }
 #endif
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd && s != Unix ) {
 #else
     if ( s != Unix ) {
 #endif
-#ifdef Q_OS_MAC
+#if !defined(QWS) && defined(Q_OS_MAC)
 	if(s != Mac) //mac is respected on the mac as well
 #endif
 	    return;
     }
 
     if (path == d->searchPaths.first() || path == d->searchPaths.last())
 	return;
 
     d->searchPaths.remove(path);
 }
 
 
 /*!
   Creates a settings object.
 */
 QSettings::QSettings()
 {
     d = new QSettingsPrivate( Native );
     Q_CHECK_PTR(d);
 
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     d->sysd = 0;
     d->sysInit();
 #endif
 }
 
 /*!
   Creates a settings object. If \a format is 'Ini' the settings will
   be stored in a text file, using the Unix strategy (see above). If \a format
   is 'Native', the settings will be stored in a platform specific way
   (ie. the Windows registry).
 */
 QSettings::QSettings( Format format )
 {
     d = new QSettingsPrivate( format );
     Q_CHECK_PTR(d);
 
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     d->sysd = 0;
     if ( format == Native )
 	d->sysInit();
 #else
     Q_UNUSED(format);
 #endif
 }
 
 /*!
   Destroys the settings object.  All modifications made to the settings
   will automatically be saved.
 
 */
 QSettings::~QSettings()
 {
     sync();
 
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
 	d->sysClear();
 #endif
 
     delete d;
 }
 
 
 /*! \internal
   Writes all modifications to the settings to disk.  If any errors are
   encountered, this function returns FALSE, otherwise it will return TRUE.
 */
 bool QSettings::sync()
 {
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
 	return d->sysSync();
 #endif
     if (! d->modified)
 	// fake success
 	return TRUE;
 
     bool success = TRUE;
     QMap<QString,QSettingsHeading>::Iterator it = d->headings.begin();
 
     while (it != d->headings.end()) {
 	// determine filename
 	QSettingsHeading hd(*it);
 	QSettingsHeading::Iterator hdit = hd.begin();
 	QFile file;
 
 	QStringList::Iterator pit = d->searchPaths.begin();
+	if ( !d->globalScope )
+	    ++pit;
 	while (pit != d->searchPaths.end()) {
 	    QString filebase = it.key().lower().replace(QRegExp("\\s+"), "_");
 	    QFileInfo di(*pit);
 	    QFileInfo fi((*pit++) + "/" + filebase + "rc");
 
 	    if ((fi.exists() && fi.isFile() && fi.isWritable()) ||
 		(! fi.exists() && di.isDir() && di.isWritable())) {
 		file.setName(fi.filePath());
 		break;
 	    }
 	}
 
-	it++;
+	++it;
 
-	if (file.name().isNull() || file.name().isEmpty()) {
+	if ( file.name().isEmpty() ) {
 
 #ifdef QT_CHECK_STATE
 	    qWarning("QSettings::sync: filename is null/empty");
 #endif // QT_CHECK_STATE
 
 	    success = FALSE;
 	    continue;
 	}
 
 	HANDLE lockfd = openlock( file.name(), Q_LOCKWRITE );
 
 	if (! file.open(IO_WriteOnly)) {
 
 #ifdef QT_CHECK_STATE
 	    qWarning("QSettings::sync: failed to open '%s' for writing",
 		     file.name().latin1());
 #endif // QT_CHECK_STATE
 
 	    success = FALSE;
 	    continue;
 	}
 
 	// spew to file
 	QTextStream stream(&file);
 	stream.setEncoding(QTextStream::UnicodeUTF8);
 
 	while (hdit != hd.end()) {
 	    if ((*hdit).count() > 0) {
 		stream << "[" << hdit.key() << "]" << endl;
 
 		QSettingsGroup grp(*hdit);
 		QSettingsGroup::Iterator grpit = grp.begin();
 
 		while (grpit != grp.end()) {
 		    QString v = grpit.data();
 		    if ( v.isNull() ) {
 			v = "\\0"; // escape null string
 		    } else {
 			v.replace("\\", "\\\\"); // escape backslash
 			v.replace("\n", "\\n"); // escape newlines
 		    }
 
 		    stream << grpit.key() << "=" << v << endl;
-		    grpit++;
+		    ++grpit;
 		}
 
 		stream << endl;
 	    }
 
-	    hdit++;
+	    ++hdit;
 	}
 
 	if (file.status() != IO_Ok) {
 
 #ifdef QT_CHECK_STATE
 	    qWarning("QSettings::sync: error at end of write");
 #endif // QT_CHECK_STATE
 
 	    success = FALSE;
 	}
 
 	file.close();
 
 	closelock( lockfd );
     }
 
     d->modified = FALSE;
 
     return success;
 }
 
 
 /*!
   \fn bool QSettings::readBoolEntry(const QString &key, bool def, bool *ok ) const
 
   Reads the entry specified by \a key, and returns a bool, or the
   default value, \a def, if the entry couldn't be read.
   If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE
   otherwise.
 
   \sa readEntry(), readNumEntry(), readDoubleEntry(), writeEntry(), removeEntry()
 */
 
 /*!
     \internal
 */
 bool QSettings::readBoolEntry(const QString &key, bool def, bool *ok )
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::readBoolEntry: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
     	if ( ok )
 	    *ok = FALSE;
 
 	return def;
     }
 
-    QString theKey = groupKey( group(), key );
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
-	return d->sysReadBoolEntry( theKey, def, ok );
+	return d->sysReadBoolEntry( groupKey( group(), key ), def, ok );
 #endif
 
-    QString value = readEntry( theKey, ( def ? "true" : "false" ), ok );
+    QString value = readEntry( key, ( def ? "true" : "false" ), ok );
 
     if (value.lower() == "true")
 	return TRUE;
     else if (value.lower() == "false")
 	return FALSE;
     else if (value == "1")
 	return TRUE;
     else if (value == "0")
 	return FALSE;
 
     if (! value.isEmpty())
 	qWarning("QSettings::readBoolEntry: '%s' is not 'true' or 'false'",
 		 value.latin1());
     if ( ok )
 	*ok = FALSE;
     return def;
 }
 
 
 /*!
     \fn double QSettings::readDoubleEntry(const QString &key, double def, bool *ok ) const
 
   Reads the entry specified by \a key, and returns a double, or the
   default value, \a def, if the entry couldn't be read.
   If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE
   otherwise.
 
   \sa readEntry(), readNumEntry(), readBoolEntry(), writeEntry(), removeEntry()
 */
 
 /*!
     \internal
 */
 double QSettings::readDoubleEntry(const QString &key, double def, bool *ok )
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::readDoubleEntry: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
     	if ( ok )
 	    *ok = FALSE;
 
 	return def;
     }
 
-    QString theKey = groupKey( group(), key );
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
-	return d->sysReadDoubleEntry( theKey, def, ok );
+	return d->sysReadDoubleEntry( groupKey( group(), key ), def, ok );
 #endif
 
-    QString value = readEntry( theKey, QString::number(def), ok );
+    QString value = readEntry( key, QString::number(def), ok );
     bool conv_ok;
     double retval = value.toDouble( &conv_ok );
     if ( conv_ok )
 	return retval;
     if ( ! value.isEmpty() )
 	qWarning( "QSettings::readDoubleEntry: '%s' is not a number",
 		  value.latin1() );
     if ( ok )
 	*ok = FALSE;
     return def;
 }
 
 
 /*!
     \fn int QSettings::readNumEntry(const QString &key, int def, bool *ok ) const
 
   Reads the entry specified by \a key, and returns an integer, or the
   default value, \a def, if the entry couldn't be read.
   If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE
   otherwise.
 
   \sa readEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry()
 */
 
 /*!
     \internal
 */
 int QSettings::readNumEntry(const QString &key, int def, bool *ok )
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::readNumEntry: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	if ( ok )
 	    *ok = FALSE;
 	return def;
     }
 
-    QString theKey = groupKey( group(), key );
-
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
-	return d->sysReadNumEntry( theKey, def, ok );
+	return d->sysReadNumEntry( groupKey( group(), key ), def, ok );
 #endif
 
-    QString value = readEntry( theKey, QString::number( def ), ok );
+    QString value = readEntry( key, QString::number( def ), ok );
     bool conv_ok;
     int retval = value.toInt( &conv_ok );
     if ( conv_ok )
 	return retval;
     if ( ! value.isEmpty() )
 	qWarning( "QSettings::readNumEntry: '%s' is not a number",
 		  value.latin1() );
     if ( ok )
 	*ok = FALSE;
     return def;
 }
 
 
 /*!
     \fn QString QSettings::readEntry(const QString &key, const QString &def, bool *ok ) const
 
   Reads the entry specified by \a key, and returns a QString, or the
   default value, \a def, if the entry couldn't be read.
   If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE
   otherwise.
 
   \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry()
 */
 
 /*!
     \internal
 */
 QString QSettings::readEntry(const QString &key, const QString &def, bool *ok )
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::readEntry: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	if ( ok )
 	    *ok = FALSE;
 
 	return def;
     }
 
     QString theKey = groupKey( group(), key );
 
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
 	return d->sysReadEntry( theKey, def, ok );
 #endif
 
     if ( ok ) // no, everything is not ok
 	*ok = FALSE;
 
     QString realkey;
 
     if (theKey[0] == '/') {
 	// parse our key
 	QStringList list(QStringList::split('/', theKey));
 
 	if (list.count() < 2) {
 #ifdef QT_CHECK_STATE
 	    qWarning("QSettings::readEntry: invalid key '%s'", theKey.latin1());
 #endif // QT_CHECK_STATE
 	    if ( ok )
 		*ok = FALSE;
 	    return def;
 	}
 
 	if (list.count() == 2) {
 	    d->heading = list[0];
 	    d->group = "General";
 	    realkey = list[1];
 	} else {
 	    d->heading = list[0];
 	    d->group = list[1];
 
 	    // remove the group from the list
 	    list.remove(list.at(1));
 	    // remove the heading from the list
 	    list.remove(list.at(0));
 
 	    realkey = list.join("/");
 	}
     } else
     	realkey = theKey;
 
     QSettingsGroup grp = d->readGroup();
-    QString retval = grp[realkey];
-    if ( retval.isNull() )
-	retval = def;
-    else if ( ok ) // everything is ok
-	*ok = TRUE;
+    QSettingsGroup::const_iterator it = grp.find( realkey ), end = grp.end();
+    QString retval = def;
+    if ( it != end ) {
+	// found the value we needed
+	retval = *it;
+	if ( ok ) *ok = TRUE;
+    }
     return retval;
 }
 
 
 #if !defined(Q_NO_BOOL_TYPE)
 /*!
     Writes the boolean entry \a value into key \a key. The \a key is
     created if it doesn't exist. Any previous value is overwritten by \a
     value.
 
     If an error occurs the settings are left unchanged and FALSE is
     returned; otherwise TRUE is returned.
 
   \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
 */
 bool QSettings::writeEntry(const QString &key, bool value)
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::writeEntry: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	return FALSE;
     }
 
-    QString theKey = groupKey( group(), key );
-
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
-	return d->sysWriteEntry( theKey, value );
+	return d->sysWriteEntry( groupKey( group(), key ), value );
 #endif
     QString s(value ? "true" : "false");
-    return writeEntry(theKey, s);
+    return writeEntry(key, s);
 }
 #endif
 
 
 /*!
     \overload
     Writes the double entry \a value into key \a key. The \a key is
     created if it doesn't exist. Any previous value is overwritten by \a
     value.
 
     If an error occurs the settings are left unchanged and FALSE is
     returned; otherwise TRUE is returned.
 
   \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
 */
 bool QSettings::writeEntry(const QString &key, double value)
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::writeEntry: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	return FALSE;
     }
 
-    QString theKey = groupKey( group(), key );
-
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
-	return d->sysWriteEntry( theKey, value );
+	return d->sysWriteEntry( groupKey( group(), key ), value );
 #endif
     QString s(QString::number(value));
-    return writeEntry(theKey, s);
+    return writeEntry(key, s);
 }
 
 
 /*!
     \overload
     Writes the integer entry \a value into key \a key. The \a key is
     created if it doesn't exist. Any previous value is overwritten by \a
     value.
 
     If an error occurs the settings are left unchanged and FALSE is
     returned; otherwise TRUE is returned.
 
   \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
 */
 bool QSettings::writeEntry(const QString &key, int value)
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::writeEntry: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	return FALSE;
     }
 
-    QString theKey = groupKey( group(), key );
-
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
-	return d->sysWriteEntry( theKey, value );
+	return d->sysWriteEntry( groupKey( group(), key ), value );
 #endif
     QString s(QString::number(value));
-    return writeEntry(theKey, s);
+    return writeEntry(key, s);
 }
 
 
 /*!
     \internal
 
   Writes the entry specified by \a key with the string-literal \a value,
   replacing any previous setting.  If \a value is zero-length or null, the
   entry is replaced by an empty setting.
 
   \e NOTE: This function is provided because some compilers use the
   writeEntry (const QString &, bool) overload for this code:
   writeEntry ("/foo/bar", "baz")
 
   If an error occurs, this functions returns FALSE and the object is left
   unchanged.
 
   \sa readEntry(), removeEntry()
 */
 bool QSettings::writeEntry(const QString &key, const char *value)
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::writeEntry: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	return FALSE;
     }
 
-    QString theKey = groupKey( group(), key );
-
-    return writeEntry(theKey, QString(value));
+    return writeEntry(key, QString(value));
 }
 
 
 /*!
     \overload
     Writes the string entry \a value into key \a key. The \a key is
     created if it doesn't exist. Any previous value is overwritten by \a
     value. If \a value is an empty string or a null string the key's
     value will be an empty string.
 
     If an error occurs the settings are left unchanged and FALSE is
     returned; otherwise TRUE is returned.
 
   \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
 */
 bool QSettings::writeEntry(const QString &key, const QString &value)
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::writeEntry: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	return FALSE;
     }
 
     QString theKey = groupKey( group(), key );
 
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
 	return d->sysWriteEntry( theKey, value );
 #endif
     // NOTE: we *do* allow value to be a null/empty string
 
     QString realkey;
 
     if (theKey[0] == '/') {
 	// parse our key
 	QStringList list(QStringList::split('/', theKey));
 
 	if (list.count() < 2) {
 #ifdef QT_CHECK_STATE
 	    qWarning("QSettings::writeEntry: invalid key '%s'", theKey.latin1());
 #endif // QT_CHECK_STATE
 
 	    return FALSE;
 	}
 
 	if (list.count() == 2) {
 	    d->heading = list[0];
 	    d->group = "General";
 	    realkey = list[1];
 	} else {
 	    d->heading = list[0];
 	    d->group = list[1];
 
 	    // remove the group from the list
 	    list.remove(list.at(1));
 	    // remove the heading from the list
 	    list.remove(list.at(0));
 
 	    realkey = list.join("/");
 	}
     } else
 	realkey = theKey;
 
     d->writeGroup(realkey, value);
     return TRUE;
 }
 
 
 /*!
   Removes the entry specified by \a key.
 
     Returns TRUE if the entry existed and was removed; otherwise returns FALSE.
 
   \sa readEntry(), writeEntry()
 */
 bool QSettings::removeEntry(const QString &key)
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::removeEntry: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	return FALSE;
     }
 
     QString theKey = groupKey( group(), key );
 
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
 	return d->sysRemoveEntry( theKey );
 #endif
 
     QString realkey;
 
     if (theKey[0] == '/') {
 	// parse our key
 	QStringList list(QStringList::split('/', theKey));
 
 	if (list.count() < 2) {
 #ifdef QT_CHECK_STATE
 	    qWarning("QSettings::removeEntry: invalid key '%s'", theKey.latin1());
 #endif // QT_CHECK_STATE
 
 	    return FALSE;
 	}
 
 	if (list.count() == 2) {
 	    d->heading = list[0];
 	    d->group = "General";
 	    realkey = list[1];
 	} else {
 	    d->heading = list[0];
 	    d->group = list[1];
 
 	    // remove the group from the list
 	    list.remove(list.at(1));
 	    // remove the heading from the list
 	    list.remove(list.at(0));
 
 	    realkey = list.join("/");
 	}
     } else
 	realkey = theKey;
 
     d->removeGroup(realkey);
     return TRUE;
 }
 
 
 /*!
   Returns a list of the keys which contain entries under \a key. Does \e
   not return any keys that contain keys.
 
     Example settings:
     \code
     /MyCompany/MyApplication/background color
     /MyCompany/MyApplication/foreground color
     /MyCompany/MyApplication/geometry/x
     /MyCompany/MyApplication/geometry/y
     /MyCompany/MyApplication/geometry/width
     /MyCompany/MyApplication/geometry/height
     \endcode
     \code
     QStringList keys = entryList( "/MyCompany/MyApplication" );
     \endcode
     \c keys contains 'background color' and 'foreground color'. It does
     not contain 'geometry' because this key contains keys not entries.
 
     To access the geometry values could either use subkeyList() to read
     the keys and then read each entry, or simply read each entry
     directly by specifying its full key, e.g.
     "/MyCompany/MyApplication/geometry/y".
 
   \sa subkeyList()
 */
 QStringList QSettings::entryList(const QString &key) const
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::entryList: Invalid key: %s", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	return QStringList();
     }
 
     QString theKey = groupKey( group(), key );
 
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
 	return d->sysEntryList( theKey );
 #endif
 
     QString realkey;
     if (theKey[0] == '/') {
 	// parse our key
 	QStringList list(QStringList::split('/', theKey));
 
 	if (list.count() < 1) {
 #ifdef QT_CHECK_STATE
 	    qWarning("QSettings::listEntries: invalid key '%s'", theKey.latin1());
 #endif // QT_CHECK_STATE
 
 	    return QStringList();
 	}
 
 	if (list.count() == 1) {
 	    d->heading = list[0];
 	    d->group = "General";
 	} else {
 	    d->heading = list[0];
 	    d->group = list[1];
 
 	    // remove the group from the list
 	    list.remove(list.at(1));
 	    // remove the heading from the list
 	    list.remove(list.at(0));
 
 	    realkey = list.join("/");
 	}
     } else
 	realkey = theKey;
 
     QSettingsGroup grp = d->readGroup();
     QSettingsGroup::Iterator it = grp.begin();
     QStringList ret;
     QString itkey;
     while (it != grp.end()) {
 	itkey = it.key();
-	it++;
+	++it;
 
 	if ( realkey.length() > 0 ) {
 	    if ( itkey.left( realkey.length() ) != realkey )
 		continue;
 	    else
 		itkey.remove( 0, realkey.length() + 1 );
 	}
 
 	if ( itkey.find( '/' ) != -1 )
 	    continue;
 
 	ret << itkey;
     }
 
     return ret;
 }
 
 
 /*!
   Returns a list of the keys which contain keys under \a key. Does \e
   not return any keys that contain entries.
 
     Example settings:
     \code
     /MyCompany/MyApplication/background color
     /MyCompany/MyApplication/foreground color
     /MyCompany/MyApplication/geometry/x
     /MyCompany/MyApplication/geometry/y
     /MyCompany/MyApplication/geometry/width
     /MyCompany/MyApplication/geometry/height
     /MyCompany/MyApplication/recent files/1
     /MyCompany/MyApplication/recent files/2
     /MyCompany/MyApplication/recent files/3
     \endcode
     \code
     QStringList keys = subkeyList( "/MyCompany/MyApplication" );
     \endcode
     \c keys contains 'geometry' and 'recent files'. It does not contain
     'background color' or 'foreground color' because they are keys which
     contain entries not keys. To get a list of keys that have values
     rather than subkeys use entryList().
 
   \sa entryList()
 */
 QStringList QSettings::subkeyList(const QString &key) const
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::subkeyList: Invalid key: %s", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	return QStringList();
     }
 
     QString theKey = groupKey( group(), key );
 
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
 	return d->sysSubkeyList( theKey );
 #endif
 
     QString realkey;
+    int subkeycount = 2;
     if (theKey[0] == '/') {
 	// parse our key
 	QStringList list(QStringList::split('/', theKey));
 
 	if (list.count() < 1) {
 #ifdef QT_CHECK_STATE
 	    qWarning("QSettings::subkeyList: invalid key '%s'", theKey.latin1());
 #endif // QT_CHECK_STATE
 
 	    return QStringList();
 	}
 
+	subkeycount = list.count();
+
 	if (list.count() == 1) {
 	    d->heading = list[0];
 	    d->group = "General";
 	} else {
 	    d->heading = list[0];
 	    d->group = list[1];
 
 	    // remove the group from the list
 	    list.remove(list.at(1));
 	    // remove the heading from the list
 	    list.remove(list.at(0));
 
 	    realkey = list.join("/");
 	}
+
     } else
 	realkey = theKey;
 
+    QStringList ret;
+    if ( subkeycount == 1 ) {
+	QMap<QString,QSettingsHeading>::Iterator it = d->headings.begin();
+	while ( it != d->headings.end() ) {
+	    if ( it.key() != "General" && ! ret.contains( it.key() ) )
+		ret << it.key();
+	    ++it;
+	}
+
+	return ret;
+    }
+
     QSettingsGroup grp = d->readGroup();
     QSettingsGroup::Iterator it = grp.begin();
-    QStringList ret;
     QString itkey;
     while (it != grp.end()) {
 	itkey = it.key();
-	it++;
+	++it;
 
 	if ( realkey.length() > 0 ) {
 	    if ( itkey.left( realkey.length() ) != realkey )
 		continue;
 	    else
 		itkey.remove( 0, realkey.length() + 1 );
 	}
 
 	int slash = itkey.find( '/' );
 	if ( slash == -1 )
 	    continue;
 	itkey.truncate( slash );
 
 	if ( ! ret.contains( itkey ) )
 	    ret << itkey;
     }
 
     return ret;
 }
 
 
 /*!
     \internal
 
   This function returns the time of last modification for \a key.
 */
 QDateTime QSettings::lastModficationTime(const QString &key)
 {
-    if ( !verifyKey( key ) ) {
+    if ( !qt_verify_key( key ) ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QSettings::lastModficationTime: Invalid key: '%s'", key.isNull() ? "(null)" : key.latin1() );
 #endif
 	return QDateTime();
     }
 
     QString theKey = groupKey( group(), key );
 
-#if defined(Q_WS_WIN) || defined(Q_OS_MAC)
+#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
     if ( d->sysd )
 	return QDateTime();
 #endif
 
     if (theKey[0] == '/') {
 	// parse our key
 	QStringList list(QStringList::split('/', theKey));
 
 	if (list.count() < 2) {
 #ifdef QT_CHECK_STATE
 	    qWarning("QSettings::lastModficationTime: invalid key '%s'", theKey.latin1());
 #endif // QT_CHECK_STATE
 
 	    return QDateTime();
 	}
 
 	if (list.count() == 2) {
 	    d->heading = list[0];
 	    d->group = "General";
 	} else {
 	    d->heading = list[0];
 	    d->group = list[1];
 	}
     }
 
     return d->modificationTime();
 }
 
 
 /*!
     \overload
 
     Writes the string list entry \a value into key \a key. The \a key
     is created if it doesn't exist. Any previous value is overwritten
     by \a value. The list is stored as a sequence of strings separated
-    by \a separator, so none of the strings in the list should contain
-    the separator. If the list is empty or null the key's value will
-    be an empty string.
+    by \a separator (using QStringList::join()), so none of the
+    strings in the list should contain the separator. If the list is
+    empty or null the key's value will be an empty string.
+
+    \warning The list should not contain empty or null strings, as
+    readListEntry() will use QStringList::split() to recreate the
+    list.  As the documentation states, QStringList::split() will omit
+    empty strings from the list.  Because of this, it is impossible to
+    retrieve identical list data that is stored with this function.
+    We recommend using the writeEntry() and readListEntry() overloads
+    that do not take a \a separator argument.
 
     If an error occurs the settings are left unchanged and FALSE is
     returned; otherwise returns TRUE.
 
     \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
 */
 bool QSettings::writeEntry(const QString &key, const QStringList &value,
 			   const QChar &separator)
 {
     QString s(value.join(separator));
     return writeEntry(key, s);
 }
 
 /*!
     \overload
 
     Writes the string list entry \a value into key \a key. The \a key
     is created if it doesn't exist. Any previous value is overwritten
     by \a value.
 
     If an error occurs the settings are left unchanged and FALSE is
     returned; otherwise returns TRUE.
 
     \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
 */
 bool QSettings::writeEntry(const QString &key, const QStringList &value)
 {
     QString s;
     for (QStringList::ConstIterator it=value.begin(); it!=value.end(); ++it) {
 	QString el = *it;
 	if ( el.isNull() ) {
 	    el = "^0";
 	} else {
 	    el.replace("^", "^^");
 	}
 	s+=el;
 	s+="^e"; // end of element
     }
     return writeEntry(key, s);
 }
 
 
 /*!
     \overload QStringList QSettings::readListEntry(const QString &key, const QChar &separator, bool *ok ) const
 
     Reads the entry specified by \a key as a string. The \a separator
     is used to create a QStringList by calling QStringList::split(\a
     separator, entry). If \a ok is not 0: \a *ok is set to TRUE if the
     key was read, otherwise \a *ok is set to FALSE.
 
+    \warning As the documentation states, QStringList::split() will
+    omit empty strings from the list.  Because of this, it is
+    impossible to retrieve identical list data with this function.  We
+    recommend using the readListEntry() and writeEntry() overloads
+    that do not take a \a separator argument.
+
+
     Note that if you want to iterate over the list, you should iterate
     over a copy, e.g.
     \code
     QStringList list = mySettings.readListEntry( "size", " " );
     QStringList::Iterator it = list.begin();
     while( it != list.end() ) {
 	myProcessing( *it );
 	++it;
     }
     \endcode
 
     \sa readEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry(), QStringList::split()
 */
 
 /*!
     \internal
 */
 QStringList QSettings::readListEntry(const QString &key, const QChar &separator, bool *ok )
 {
     QString value = readEntry( key, QString::null, ok );
     if ( ok && !*ok )
 	return QStringList();
 
     return QStringList::split(separator, value);
 }
 
 /*!
     \fn QStringList QSettings::readListEntry(const QString &key, bool *ok ) const
     Reads the entry specified by \a key as a string. If \a ok is not
     0, \a *ok is set to TRUE if the key was read, otherwise \a *ok is
     set to FALSE.
 
     Note that if you want to iterate over the list, you should iterate
     over a copy, e.g.
     \code
     QStringList list = mySettings.readListEntry( "recentfiles" );
     QStringList::Iterator it = list.begin();
     while( it != list.end() ) {
 	myProcessing( *it );
 	++it;
     }
     \endcode
 
     \sa readEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry(), QStringList::split()
 */
 
 /*!
     \internal
 */
 QStringList QSettings::readListEntry(const QString &key, bool *ok )
 {
     QString value = readEntry( key, QString::null, ok );
     if ( ok && !*ok )
 	return QStringList();
     QStringList l;
     QString s;
     bool esc=FALSE;
     for (int i=0; i<(int)value.length(); i++) {
 	if ( esc ) {
 	    if ( value[i] == 'e' ) { // end-of-string
 		l.append(s);
 		s="";
 	    } else if ( value[i] == '0' ) { // null string
 		s=QString::null;
 	    } else {
 		s.append(value[i]);
 	    }
 	    esc=FALSE;
 	} else if ( value[i] == '^' ) {
 	    esc = TRUE;
 	} else {
 	    s.append(value[i]);
 	    if ( i == (int)value.length()-1 )
 		l.append(s);
 	}
     }
     return l;
 }
 
+#ifdef Q_OS_MAC
+void qt_setSettingsBasePath(const QString &); //qsettings_mac.cpp
+#endif
+
 /*!
-  Insert platform-dependent paths from platform-independent information.
+    Insert platform-dependent paths from platform-independent information.
+
+    The \a domain should be an Internet domain name
+    controlled by the producer of the software, eg. Trolltech products
+    use "trolltech.com".
 
-  The \a domain should be an Internet domain name
-  controlled by the producer of the software, eg. Trolltech products
-  use "trolltech.com".
+    The \a product should be the official name of the product.
 
-  The \a product should be the official name of the product.
+    The \a scope should be
+    QSettings::User for user-specific settings, or
+    QSettings::Global for system-wide settings (generally
+    these will be read-only to many users).
 
-  The \a scope should be
-  QSettings::User for user-specific settings, or
-  QSettings::Global for system-wide settings (generally
-  these will be read-only to many users).
+    Not all information is relevant on all systems (e.g. scoping is
+    currently used only if QSettings accesses the Windows registry).
 */
 
 void QSettings::setPath( const QString &domain, const QString &product, Scope scope )
 {
 //    On Windows, any trailing ".com(\..*)" is stripped from the domain. The
 //    Global scope corresponds to HKEY_LOCAL_MACHINE, and User corresponds to
 //    HKEY_CURRENT_USER. Note that on some installations, not all users can
 //    write to the Global scope. On UNIX, any trailing ".com(\..*)" is stripped
 //    from the domain. The Global scope corresponds to "/opt" (this would be
 //    configurable at library build time - eg. to "/usr/local" or "/usr"),
 //    while the User scope corresponds to $HOME/.*rc.
 //    Note that on most installations, not all users can write to the System
 //    scope.
-//    
+//
 //    On MacOS X, if there is no "." in domain, append ".com", then reverse the
 //    order of the elements (Mac OS uses "com.apple.finder" as domain+product).
 //    The Global scope corresponds to /Library/Preferences/*.plist, while the
 //    User scope corresponds to ~/Library/Preferences/*.plist.
 //    Note that on most installations, not all users can write to the System
 //    scope.
+    d->globalScope = scope == Global;
+
     QString actualSearchPath;
     int lastDot = domain.findRev( '.' );
 
 #if defined(Q_WS_WIN)
     actualSearchPath = "/" + domain.mid( 0, lastDot ) + "/" + product;
     insertSearchPath( Windows, actualSearchPath );
-#elif defined(Q_WS_MAC)
+#elif !defined(QWS) && defined(Q_OS_MAC)
     QString topLevelDomain = domain.right( domain.length() - lastDot - 1 ) + ".";
-    if ( topLevelDomain.isEmpty() )
-	topLevelDomain = "com.";
-    actualSearchPath = "/" + topLevelDomain + domain.left( lastDot ) + product;
+    if ( !topLevelDomain.isEmpty() )
+	qt_setSettingsBasePath( topLevelDomain );
+    actualSearchPath = "/" + domain.left( lastDot ) + product;
     insertSearchPath( Mac, actualSearchPath );
 #else
     actualSearchPath = "/" + domain.mid( 0, lastDot ) + "/" + product;
     insertSearchPath( Unix, actualSearchPath );
 #endif
-
-    d->globalScope = scope == Global;
 }
 
 /*!
     Appends \a group to the current key prefix.
+
+    \code
+    QSettings settings;
+    settings.beginGroup( "/MainWindow" );
+    // read values
+    settings.endGroup();
+    \endcode
 */
 void QSettings::beginGroup( const QString &group )
 {
     d->groupStack.push( group );
     d->groupDirty = TRUE;
 }
 
 /*!
     Undo previous calls to beginGroup(). Note that a single beginGroup("a/b/c") is undone
     by a single call to endGroup().
+
+    \code
+    QSettings settings;
+    settings.beginGroup( "/MainWindow/Geometry" );
+    // read values
+    settings.endGroup();
+    \endcode
 */
 void QSettings::endGroup()
 {
     d->groupStack.pop();
     d->groupDirty = TRUE;
 }
 
 /*!
     Set the current key prefix to the empty string.
 */
 void QSettings::resetGroup()
 {
     d->groupStack.clear();
     d->groupDirty = FALSE;
     d->groupPrefix = QString::null;
 }
 
 /*!
     Returns the current key prefix, or a null string if there is no key prefix set.
 
     \sa beginGroup();
 */
 QString QSettings::group() const
 {
     if ( d->groupDirty ) {
 	d->groupDirty = FALSE;
 	d->groupPrefix = QString::null;
 
 	QValueStack<QString>::Iterator it = d->groupStack.begin();
 	while ( it != d->groupStack.end() ) {
 	    QString group = *it;
 	    ++it;
 	    if ( group[0] != '/' )
-		group = "/" + group;
+		group.prepend( "/" );
 	    d->groupPrefix += group;
 	}
     }
     return d->groupPrefix;
 }
 
 #endif
diff --git a/qmake/tools/qstring.cpp b/qmake/tools/qstring.cpp
index 56df62b..7f1fac3 100644
--- a/qmake/tools/qstring.cpp
+++ b/qmake/tools/qstring.cpp
@@ -1,17867 +1,18013 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of the QString class and related Unicode functions
 **
 ** Created : 920722
 **
-** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 // Don't define it while compiling this module, or USERS of Qt will
 // not be able to link.
 #ifdef QT_NO_CAST_ASCII
 #undef QT_NO_CAST_ASCII
 #endif
 
 #include "qstring.h"
 #include "qregexp.h"
 #include "qdatastream.h"
 #ifndef QT_NO_TEXTCODEC
 #include "qtextcodec.h"
 #endif
-#include <ctype.h>
 #include <limits.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #if defined(Q_WS_WIN)
 #include "qt_windows.h"
 #endif
 #if !defined( QT_NO_COMPONENT ) && !defined( QT_LITE_COMPONENT )
 #include "qcleanuphandler.h"
 #endif
 
+#ifdef QT_NO_UNICODETABLES
+# include <ctype.h>
+#endif
+
 
 /* -------------------------------------------------------------------------
  * unicode information
  * these tables are generated from the unicode reference file
  * ftp://ftp.unicode.org/Public/3.2-Update/UnicodeData.txt
  *
  * Lars
  * -------------------------------------------------------------------------
  */
 
 /* Perl script to generate (run perl -x tools/qstring.cpp)
 
 #!perl
 
 sub numberize
 {
     my(%r, $n, $id);
     for $id ( @_ ) {
       $i = $id;
 	$i="" if $i eq "EMPTY";
 	$r{$i}=$n++;
     }
     return %r;
 }
 
 
 sub readUnicodeDataLine {
     $code = shift @_;
     for $n (qw{
 	    name category combining_class bidi_category
 	    character_decomposition decimal_digit_value digit_value
 	    numeric_value mirrored oldname comment
 	    uppercase lowercase titlecase})
     {
 	$id = shift @_;
 	$codes = "${n}_code";
 	if ( defined %$codes && defined $$codes{$id} ) {
 	    $id = $$codes{$id};
 	}
 	${$n}{$code}=$id;
     }
     $decomp = $character_decomposition{$code};
     if ( length $decomp == 0 ) {
 	$decomp = "<single>";
     }
     if (substr($decomp, 0, 1) ne '<') {
 	$decomp = "<canonical> " . $decomp;
     }
     @_ = split(" ", $decomp);
     $tag = shift @_;
     $tag = $character_decomposition_tag{$tag};
     $decomp = join( ", 0x", @_ );
     $decomp = "0x".$decomp;
     $decomposition{$code} = $decomp;
     $decomposition_tag{$code} = $tag;
     $decomposition_pos{$code} = $position;
     $len = scalar(@_);
     $decomposition_len{$code} = $len;
 
 #   we use canonical decompositions longer than 1 char
 #   we exlude Arabic ligatures from the table
     if($len > 1 and $tag == 1) {
 #      ligature to add...
 	$start = shift @_;
 	$ligature{$start} = $ligature{$start}." ".$code;
     }
 
 #   adjust position
     if($len != 0) {
 	$position += $len + 3;
     }
 }
 
 
 # Code to integer mappings...
 #
 %category_code = numberize(qw{
       EMPTY
       Mn Mc Me
       Nd Nl No
       Zs Zl Zp
       Cc Cf Cs Co Cn
 
       Lu Ll Lt Lm Lo
       Pc Pd Ps Pe Pi Pf Po
       Sm Sc Sk So
 });
 %bidi_category_code = numberize(qw{
       L R EN ES ET AN CS B S WS ON LRE LRO AL RLE RLO PDF NSM BN});
 %character_decomposition_tag = numberize(qw{
       <single> <canonical> <font> <noBreak> <initial> <medial>
       <final> <isolated> <circle> <super> <sub> <vertical>
       <wide> <narrow> <small> <square> <compat> <fraction>
 });
 %mirrored_code = numberize(qw{N Y});
 
 %joining_code = numberize(qw{U D R C});
 
 # Read data into hashes...
 #
 open IN, "UnicodeData.txt";
 $position = 1;
 while (<IN>) {
     @fields = split /;/;
     if ( length($fields[0]) < 5 ) {
       if ( $fields[1] =~ /, First>/ ) {
 	$codeRangeBegin = $fields[0];
       } elsif ( $fields[1] =~ /, Last>/ ) {
 	for ( $i=hex($codeRangeBegin); $i<=hex($fields[0]); $i+=1 ) {
 	  @fields2 = @fields;
 	  $fields2[0] = sprintf "%lX", $i;
 	  readUnicodeDataLine @fields2;
 	}
       } else {
 	readUnicodeDataLine @fields;
       }
     }
 }
 
 open IN2, "ArabicShaping.txt";
 $position = 1;
 while (<IN2>) {
     @fields = split /;/;
     $code = shift @fields;
     $dummy = shift @fields;
     $join = shift @fields;
     $join =~ s/ //g;
     $join = $joining_code{$join};
     $joining{$code}=$join;
 }
 
 # Build pages...
 #
 $rowtable_txt =
     "static const Q_UINT8 * const unicode_info[256] = {";
 for $row ( 0..255 ) {
     $nonzero=0;
     $txt = "";
     for $cell ( 0..255 ) {
 	$code = sprintf("%02X%02X",$row,$cell);
 	$info = $category{$code};
 	$info = 0 if !defined $info;
 	$txt .= "\n    " if $cell%8 == 0;
 	$txt .= "$info, ";
     }
     $therow = $row{$txt};
     if ( !defined $therow ) {
 	$size+=256;
 	$therow = "ui_".sprintf("%02X",$row);
 	$rowtext{$therow} =
 	    "static const Q_UINT8 ${therow}[] = {$txt\n};\n\n";
 	$row{$txt}=$therow;
     }
     $rowtable_txt .= "\n    " if $row%8 == 0;
     $rowtable_txt .= "$therow, ";
 }
 
 print "// START OF GENERATED DATA\n\n";
 print "#ifndef QT_NO_UNICODETABLES\n\n";
 
 # Print pages...
 #
 for $r ( sort keys %rowtext ) {
     print $rowtext{$r};
 }
 print "$rowtable_txt\n};\n";
 $size += 256*4;
 print "// $size bytes\n\n";
 
 # Build decomposition tables
 #
 $rowtable_txt =
     "static const Q_UINT16 * const decomposition_info[256] = {";
 $table_txt =
     "static const Q_UINT16 decomposition_map[] = {\n    0,\n";
 for $row ( 0..255 ) {
     $nonzero=0;
     $txt = "";
     for $cell ( 0..255 ) {
 	$code = sprintf("%02X%02X",$row,$cell);
 	$txt .= "\n   " if $cell%8 == 0;
 	if( $decomposition_tag{$code} != 0 ) {
 	    $txt .= " $decomposition_pos{$code},";
 	    $table_txt .= "    $decomposition_tag{$code},";
 	    $table_txt .= " 0x$code,";
 	    $table_txt .= " $decomposition{$code}, 0,\n";
 	    $size += 2 * $decomposition_len{$code} + 6;
 	} else {
 	    $txt .= " 0,";
 	}
     }
     $therow = $row{$txt};
     if ( !defined $therow ) {
 	$size+=512;
 	$therow = "di_".sprintf("%02X",$row);
 	$dec_rowtext{$therow} =
 	    "static const Q_UINT16 ${therow}[] = {$txt\n};\n\n";
 	$row{$txt}=$therow;
     }
     $rowtable_txt .= "\n    " if $row%8 == 0;
     $rowtable_txt .= "$therow, ";
 }
 
 # Print decomposition tables
 #
 print "$table_txt\n};\n\n";
 for $r ( sort keys %dec_rowtext ) {
     print $dec_rowtext{$r};
 }
 print "$rowtable_txt\n};\n";
 $size += 256*4;
 print "// $size bytes\n\n";
 
 
 # build ligature tables
 #
 $size = 0;
 $position = 1;
 $rowtable_txt =
     "static const Q_UINT16 * const ligature_info[256] = {";
 $table_txt =
     "static const Q_UINT16 ligature_map[] = {\n    0,\n";
 for $lig_row ( 0..255 ) {
     $nonzero=0;
     $txt = "";
     for $cell ( 0..255 ) {
 	$code = sprintf("%02X%02X",$lig_row,$cell);
 	$txt .= "\n   " if $cell%8 == 0;
 	if( defined $ligature{$code} ) {
 	    $txt .= " $position,";
 	    @ligature = split(" ", $ligature{$code});
 #           we need to sort ligatures according to their length.
 #           long ones have to come first!
 	    @ligature_sort = sort { $decomposition_len{$b} <=>  $decomposition_len{$a} } @ligature;
 #           now replace each code by its position in
 #           the decomposition map.
 	    undef(@lig_pos);
 	    for $n (@ligature_sort) {
 		push(@lig_pos, $decomposition_pos{$n});
 	    }
 #           debug info
 	    if( 0 ) {
 		print "ligatures: $ligature{$code}\n";
 		$sort = join(" ", @ligature_sort);
 		print "sorted   : $sort\n";
 	    }
 	    $lig = join(", ", @lig_pos);
 	    $table_txt .= "    $lig, 0,\n";
 	    $size += 2 * scalar(@ligature) + 2;
 	    $position += scalar(@ligature) + 1;
 	} else {
 	    $txt .= " 0,";
 	}
     }
     $therow = $lig_row{$txt};
     if ( !defined $therow ) {
 	$size+=512;
 	$therow = "li_".sprintf("%02X",$lig_row);
 	$lig_rowtext{$therow} =
 	    "static const Q_UINT16 ${therow}[] = {$txt\n};\n\n";
 	$lig_row{$txt}=$therow;
     }
     $rowtable_txt .= "\n    " if $lig_row%8 == 0;
     $rowtable_txt .= "$therow, ";
 }
 
 # Print ligature tables
 #
 print "$table_txt\n};\n\n";
 for $r ( sort keys %lig_rowtext ) {
     print $lig_rowtext{$r};
 }
 print "$rowtable_txt\n};\n";
 $size += 256*4;
 print "// $size bytes\n\n";
 
 
 
 # Build direction/joining/mirrored pages...
 #
 $rowtable_txt =
     "static const Q_UINT8 * const direction_info[256] = {";
 for $dir_row ( 0..255 ) {
     $nonzero=0;
     $txt = "";
     for $cell ( 0..255 ) {
 	$code = sprintf("%02X%02X",$dir_row,$cell);
 	$dir = $bidi_category{$code};
 	$dir = 0 if !defined $dir;
 	$join = $joining{$code};
 	$join = 0 if !defined $join;
 	$mirr = $mirrored{$code};
 	$mirr = 0 if !defined $mirr;
 	$info = $dir + 32*$join + 128*$mirr;
 	$txt .= "\n    " if $cell%8 == 0;
 	$txt .= "$info, ";
     }
     $therow = $dir_row{$txt};
     if ( !defined $therow ) {
 	$size+=256;
 	$therow = "dir_".sprintf("%02X",$dir_row);
 	$dir_rowtext{$therow} =
 	    "static const Q_UINT8 ${therow}[] = {$txt\n};\n\n";
 	$dir_row{$txt}=$therow;
     }
     $rowtable_txt .= "\n    " if $dir_row%8 == 0;
     $rowtable_txt .= "$therow, ";
 }
 
 # Print pages...
 #
 for $r ( sort keys %dir_rowtext ) {
     print $dir_rowtext{$r};
 }
 print "$rowtable_txt\n};\n";
 $size += 256*4;
 print "// $size bytes\n\n";
 
 # Build table of combining classes
 #
 $rowtable_txt =
     "static const Q_UINT8 * const combining_info[256] = {";
 for $combining_row ( 0..255 ) {
     $nonzero=0;
     $txt = "";
     for $cell ( 0..255 ) {
 	$code = sprintf("%02X%02X",$combining_row,$cell);
 	$info = $combining_class{$code};
 	$info = 0 if !defined $info;
 	$txt .= "\n    " if $cell%8 == 0;
 	$txt .= "$info, ";
     }
     $therow = $combining_row{$txt};
     if ( !defined $therow ) {
 	$size+=256;
 	$therow = "cmb_".sprintf("%02X",$combining_row);
 	$combining_rowtext{$therow} =
 	    "static const Q_UINT8 ${therow}[] = {$txt\n};\n\n";
 	$combining_row{$txt}=$therow;
     }
     $rowtable_txt .= "\n    " if $combining_row%8 == 0;
     $rowtable_txt .= "$therow, ";
 }
 
 # Print pages...
 #
 for $r ( sort keys %combining_rowtext ) {
     print $combining_rowtext{$r};
 }
 print "$rowtable_txt\n};\n";
 $size += 256*4;
 print "// $size bytes\n\n";
 
 # Build case info
 #
 $rowtable_txt =
     "static const Q_UINT16 * const case_info[256] = {";
 for $row ( 0..255 ) {
     $nonzero=0;
     $txt = "";
     for $cell ( 0..255 ) {
 	$code = sprintf("%02X%02X",$row,$cell);
 	$info = $uppercase{$code};
 	if ( length( $info ) eq 0 ) {
 	  $info = $lowercase{$code};
 	}
 	$info =~ s/^0+//;
 	if ( length( $info ) eq 0 ) {
 	  $info = "0";
 	} else {
 	  $info = "0x".lc($info);
 	}
 	if ( length( $info ) ne 1 ) {
 	  $nonzero = 1;
 	}
 	$txt .= "\n    " if $cell%8 == 0;
 	$txt .= "$info, ";
     }
     $therow = $case_row{$txt};
     if ( !defined $therow && $nonzero ne 0 ) {
 	$size+=512;
 	$therow = "case_".sprintf("%02X",$row);
 	$case_rowtext{$therow} =
 	    "static const Q_UINT16 ${therow}[] = {$txt\n};\n\n";
 	$case_row{$txt}=$therow;
     }
     $rowtable_txt .= "\n    " if $row%8 == 0;
     if ( $nonzero ne 0 ) {
       $rowtable_txt .= "$therow, ";
     } else {
       $rowtable_txt .= "0, ";
     }
 }
 
 # Print pages...
 #
 for $r ( sort keys %case_rowtext ) {
     print $case_rowtext{$r};
 }
 print "$rowtable_txt\n};\n";
 $size += 256*4;
 print "// $size bytes\n\n";
 
 # Build decimal info
 #
 $rowtable_txt =
     "static const Q_INT8 * const decimal_info[256] = {";
 for $row ( 0..255 ) {
     $nonzero=0;
     $txt = "";
     for $cell ( 0..255 ) {
 	$code = sprintf("%02X%02X",$row,$cell);
 	$info = $digit_value{$code};
 	if ( length( $info ) eq 0 ) {
 	  $info = -1;
 	} else {
 	  $nonzero = 1;
 	}
 	$txt .= "\n    " if $cell%8 == 0;
 	$txt .= "$info, ";
     }
     $therow = $decimal_row{$txt};
     if ( !defined $therow && $nonzero ne 0 ) {
 	$size+=512;
 	$therow = "num_".sprintf("%02X",$row);
 	$decimal_rowtext{$therow} =
 	    "static const Q_INT8 ${therow}[] = {$txt\n};\n\n";
 	$decimal_row{$txt}=$therow;
     }
     $rowtable_txt .= "\n    " if $row%8 == 0;
     if ( $nonzero ne 0 ) {
       $rowtable_txt .= "$therow, ";
     } else {
       $rowtable_txt .= "0, ";
     }
 }
 
 # Print pages...
 #
 for $r ( sort keys %decimal_rowtext ) {
     print $decimal_rowtext{$r};
 }
 print "$rowtable_txt\n};\n";
 $size += 256*4;
 print "// $size bytes\n\n";
 
 
 
 print "#endif\n\n";
 print "// END OF GENERATED DATA\n\n";
 
 
 
 __END__
 
 */
 
 // START OF GENERATED DATA
 
 static const Q_UINT8 ui_00[] = {
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     7, 26, 26, 26, 28, 26, 26, 26,
     22, 23, 26, 27, 26, 21, 26, 26,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 26, 26, 27, 27, 27, 26,
     26, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 22, 26, 23, 29, 20,
     29, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 22, 27, 23, 27, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     7, 26, 28, 28, 28, 28, 30, 30,
     29, 30, 16, 24, 27, 21, 30, 29,
     30, 27, 6, 6, 29, 16, 30, 26,
     29, 6, 16, 25, 6, 6, 6, 26,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 27,
     15, 15, 15, 15, 15, 15, 15, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 27,
     16, 16, 16, 16, 16, 16, 16, 16,
 };
 
 #ifndef QT_NO_UNICODETABLES
 
 static const Q_UINT8 ui_01[] = {
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     16, 15, 16, 15, 16, 15, 16, 15,
     16, 15, 16, 15, 16, 15, 16, 15,
     16, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 15, 16, 15, 16, 15, 16, 16,
     16, 15, 15, 16, 15, 16, 15, 15,
     16, 15, 15, 15, 16, 16, 15, 15,
     15, 15, 16, 15, 15, 16, 15, 15,
     15, 16, 16, 16, 15, 15, 16, 15,
     15, 16, 15, 16, 15, 16, 15, 15,
     16, 15, 16, 16, 15, 16, 15, 15,
     16, 15, 15, 15, 16, 15, 16, 15,
     15, 16, 16, 19, 15, 16, 16, 16,
     19, 19, 19, 19, 15, 17, 16, 15,
     17, 16, 15, 17, 16, 15, 16, 15,
     16, 15, 16, 15, 16, 15, 16, 15,
     16, 15, 16, 15, 16, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     16, 15, 17, 16, 15, 16, 15, 15,
     15, 16, 15, 16, 15, 16, 15, 16,
 };
 
 static const Q_UINT8 ui_02[] = {
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 0, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 0, 0,
     18, 18, 18, 18, 18, 18, 18, 18,
     18, 29, 29, 18, 18, 18, 18, 18,
     18, 18, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29,
     18, 18, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29,
     18, 18, 18, 18, 18, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 18, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_03[] = {
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     0, 0, 0, 0, 29, 29, 0, 0,
     0, 0, 18, 0, 0, 0, 26, 0,
     0, 0, 0, 0, 29, 29, 15, 26,
     15, 15, 15, 0, 15, 0, 15, 15,
     16, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 0, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 0,
     16, 16, 15, 15, 15, 16, 16, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     16, 16, 16, 16, 15, 16, 27, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_04[] = {
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 30, 1, 1, 1, 1, 0,
     3, 3, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 15, 16, 15, 16, 15, 16, 15,
     16, 15, 16, 15, 16, 15, 16, 0,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 0, 0,
     15, 16, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_05[] = {
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 0,
     0, 18, 26, 26, 26, 26, 26, 26,
     0, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     0, 26, 21, 0, 0, 0, 0, 0,
     0, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 0, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 0, 1, 1, 1, 26, 1,
     26, 1, 1, 26, 1, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 0, 0, 0, 0, 0,
     19, 19, 19, 26, 26, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_06[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 26, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 26, 0, 0, 0, 26,
     0, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 0, 0, 0, 0, 0,
     18, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 26, 26, 26, 26, 19, 19,
     1, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 26, 19, 1, 1,
     1, 1, 1, 1, 1, 11, 3, 1,
     1, 1, 1, 1, 1, 18, 18, 1,
     1, 30, 1, 1, 1, 1, 0, 0,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 19, 19, 19, 30, 30, 0,
 };
 
 static const Q_UINT8 ui_07[] = {
     26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 0, 11,
     19, 1, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 0, 0,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 19, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_08[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_09[] = {
     0, 1, 1, 2, 0, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 0, 0, 1, 19, 2, 2,
     2, 1, 1, 1, 1, 1, 1, 1,
     1, 2, 2, 2, 2, 1, 0, 0,
     19, 1, 1, 1, 1, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 1, 1, 26, 26, 4, 4,
     4, 4, 4, 4, 4, 4, 4, 4,
     26, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 1, 2, 2, 0, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 0, 19,
     19, 0, 0, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 0, 0, 0, 19, 19,
     19, 19, 0, 0, 1, 0, 2, 2,
     2, 1, 1, 1, 1, 0, 0, 2,
     2, 0, 0, 2, 2, 1, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 2,
     0, 0, 0, 0, 19, 19, 0, 19,
     19, 19, 1, 1, 0, 0, 4, 4,
     4, 4, 4, 4, 4, 4, 4, 4,
     19, 19, 28, 28, 6, 6, 6, 6,
     6, 6, 30, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_0A[] = {
     0, 0, 1, 0, 0, 19, 19, 19,
     19, 19, 19, 0, 0, 0, 0, 19,
     19, 0, 0, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 19, 0, 19, 19, 0,
     19, 19, 0, 0, 1, 0, 2, 2,
     2, 1, 1, 0, 0, 0, 0, 1,
     1, 0, 0, 1, 1, 1, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 19, 19, 19, 19, 0, 19, 0,
     0, 0, 0, 0, 0, 0, 4, 4,
     4, 4, 4, 4, 4, 4, 4, 4,
     1, 1, 19, 19, 19, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 1, 1, 2, 0, 19, 19, 19,
     19, 19, 19, 19, 0, 19, 0, 19,
     19, 19, 0, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 19, 0, 19, 19, 19,
     19, 19, 0, 0, 1, 19, 2, 2,
     2, 1, 1, 1, 1, 1, 0, 1,
     1, 2, 0, 2, 2, 1, 0, 0,
     19, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 0, 0, 0, 0, 0, 4, 4,
     4, 4, 4, 4, 4, 4, 4, 4,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_0B[] = {
     0, 1, 2, 2, 0, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 0, 19,
     19, 0, 0, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 19, 0, 0, 19, 19,
     19, 19, 0, 0, 1, 19, 2, 1,
     2, 1, 1, 1, 0, 0, 0, 2,
     2, 0, 0, 2, 2, 1, 0, 0,
     0, 0, 0, 0, 0, 0, 1, 2,
     0, 0, 0, 0, 19, 19, 0, 19,
     19, 19, 0, 0, 0, 0, 4, 4,
     4, 4, 4, 4, 4, 4, 4, 4,
     30, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 1, 19, 0, 19, 19, 19,
     19, 19, 19, 0, 0, 0, 19, 19,
     19, 0, 19, 19, 19, 19, 0, 0,
     0, 19, 19, 0, 19, 0, 19, 19,
     0, 0, 0, 19, 19, 0, 0, 0,
     19, 19, 19, 0, 0, 0, 19, 19,
     19, 19, 19, 19, 19, 19, 0, 19,
     19, 19, 0, 0, 0, 0, 2, 2,
     1, 2, 2, 0, 0, 0, 2, 2,
     2, 0, 2, 2, 2, 1, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 2,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 4,
     4, 4, 4, 4, 4, 4, 4, 4,
     6, 6, 6, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_0C[] = {
     0, 2, 2, 2, 0, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 19, 19,
     19, 0, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 0, 19, 19, 19,
     19, 19, 0, 0, 0, 0, 1, 1,
     1, 2, 2, 2, 2, 0, 1, 1,
     1, 0, 1, 1, 1, 1, 0, 0,
     0, 0, 0, 0, 0, 1, 1, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 0, 0, 0, 0, 4, 4,
     4, 4, 4, 4, 4, 4, 4, 4,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 2, 2, 0, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 19, 19,
     19, 0, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 0, 19, 19, 19,
     19, 19, 0, 0, 0, 0, 2, 1,
     2, 2, 2, 2, 2, 0, 1, 2,
     2, 0, 2, 2, 1, 1, 0, 0,
     0, 0, 0, 0, 0, 2, 2, 0,
     0, 0, 0, 0, 0, 0, 19, 0,
     19, 19, 0, 0, 0, 0, 4, 4,
     4, 4, 4, 4, 4, 4, 4, 4,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_0D[] = {
     0, 0, 2, 2, 0, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 19, 19,
     19, 0, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 0, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 0, 0, 0, 0, 2, 2,
     2, 1, 1, 1, 0, 0, 2, 2,
     2, 0, 2, 2, 2, 1, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 2,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 0, 0, 0, 0, 4, 4,
     4, 4, 4, 4, 4, 4, 4, 4,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 2, 2, 0, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     0, 0, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 0, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 0, 19, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 0,
     0, 0, 1, 0, 0, 0, 0, 2,
     2, 2, 1, 1, 1, 0, 1, 0,
     2, 2, 2, 2, 2, 2, 2, 2,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 2, 2, 26, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_0E[] = {
     0, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 1, 19, 19, 1, 1, 1, 1,
     1, 1, 1, 0, 0, 0, 0, 28,
     19, 19, 19, 19, 19, 19, 18, 1,
     1, 1, 1, 1, 1, 1, 1, 26,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 26, 26, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 19, 19, 0, 19, 0, 0, 19,
     19, 0, 19, 0, 0, 19, 0, 0,
     0, 0, 0, 0, 19, 19, 19, 19,
     0, 19, 19, 19, 19, 19, 19, 19,
     0, 19, 19, 19, 0, 19, 0, 19,
     0, 0, 19, 19, 0, 19, 19, 19,
     19, 1, 19, 19, 1, 1, 1, 1,
     1, 1, 0, 1, 1, 19, 0, 0,
     19, 19, 19, 19, 19, 0, 18, 0,
     1, 1, 1, 1, 1, 1, 0, 0,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 0, 0, 19, 19, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_0F[] = {
     19, 30, 30, 30, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 30, 30, 30, 30, 30,
     1, 1, 30, 30, 30, 30, 30, 30,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 30, 1, 30, 1,
     30, 1, 22, 23, 22, 23, 2, 2,
     19, 19, 19, 19, 19, 19, 19, 19,
     0, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 0, 0, 0, 0, 0,
     0, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 2,
     1, 1, 1, 1, 1, 26, 1, 1,
     19, 19, 19, 19, 0, 0, 0, 0,
     1, 1, 1, 1, 1, 1, 1, 1,
     0, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 0, 30, 30,
     30, 30, 30, 30, 30, 30, 1, 30,
     30, 30, 30, 30, 30, 0, 0, 30,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_10[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 0, 19, 19, 19, 19, 19,
     0, 19, 19, 0, 2, 1, 1, 1,
     1, 2, 1, 0, 0, 0, 1, 1,
     2, 1, 0, 0, 0, 0, 0, 0,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 26, 26, 26, 26, 26, 26,
     19, 19, 19, 19, 19, 19, 2, 2,
     1, 1, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 0, 0, 26, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_11[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 0, 0, 0, 0, 0, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_12[] = {
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 0, 19, 19, 19, 19, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 0, 19, 19, 19, 19, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 0, 19, 19, 19, 19, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 0, 19, 19, 19, 19, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 0, 19, 19, 19, 19, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
 };
 
 static const Q_UINT8 ui_13[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 0, 19, 19, 19, 19, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 0, 0, 0, 0, 0,
     0, 26, 26, 26, 26, 26, 26, 26,
     26, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_14[] = {
     0, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
 };
 
 static const Q_UINT8 ui_15[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
 };
 
 static const Q_UINT8 ui_16[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 26, 26, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     7, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 22, 23, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 26, 26, 26, 5, 5,
     5, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_17[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 19, 19,
     19, 19, 1, 1, 1, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 1, 1, 1, 26, 26, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 1, 1, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 19, 19,
     19, 0, 1, 1, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 2, 2, 2, 1,
     1, 1, 1, 1, 1, 1, 2, 2,
     2, 2, 2, 2, 2, 2, 1, 2,
     2, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 26, 26, 26, 18,
     26, 26, 26, 28, 19, 0, 0, 0,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_18[] = {
     26, 26, 26, 26, 26, 26, 21, 26,
     26, 26, 26, 1, 1, 1, 11, 0,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 18, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 1, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_1E[] = {
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 16, 16,
     16, 16, 16, 16, 0, 0, 0, 0,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 15, 16, 15, 16, 15, 16,
     15, 16, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_1F[] = {
     16, 16, 16, 16, 16, 16, 16, 16,
     15, 15, 15, 15, 15, 15, 15, 15,
     16, 16, 16, 16, 16, 16, 0, 0,
     15, 15, 15, 15, 15, 15, 0, 0,
     16, 16, 16, 16, 16, 16, 16, 16,
     15, 15, 15, 15, 15, 15, 15, 15,
     16, 16, 16, 16, 16, 16, 16, 16,
     15, 15, 15, 15, 15, 15, 15, 15,
     16, 16, 16, 16, 16, 16, 0, 0,
     15, 15, 15, 15, 15, 15, 0, 0,
     16, 16, 16, 16, 16, 16, 16, 16,
     0, 15, 0, 15, 0, 15, 0, 15,
     16, 16, 16, 16, 16, 16, 16, 16,
     15, 15, 15, 15, 15, 15, 15, 15,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 0, 0,
     16, 16, 16, 16, 16, 16, 16, 16,
     17, 17, 17, 17, 17, 17, 17, 17,
     16, 16, 16, 16, 16, 16, 16, 16,
     17, 17, 17, 17, 17, 17, 17, 17,
     16, 16, 16, 16, 16, 16, 16, 16,
     17, 17, 17, 17, 17, 17, 17, 17,
     16, 16, 16, 16, 16, 0, 16, 16,
     15, 15, 15, 15, 17, 29, 16, 29,
     29, 29, 16, 16, 16, 0, 16, 16,
     15, 15, 15, 15, 17, 29, 29, 29,
     16, 16, 16, 16, 0, 0, 16, 16,
     15, 15, 15, 15, 0, 29, 29, 29,
     16, 16, 16, 16, 16, 16, 16, 16,
     15, 15, 15, 15, 15, 29, 29, 29,
     0, 0, 16, 16, 16, 0, 16, 16,
     15, 15, 15, 15, 17, 29, 29, 0,
 };
 
 static const Q_UINT8 ui_20[] = {
     7, 7, 7, 7, 7, 7, 7, 7,
     7, 7, 7, 7, 11, 11, 11, 11,
     21, 21, 21, 21, 21, 21, 26, 26,
     24, 25, 22, 24, 24, 25, 22, 24,
     26, 26, 26, 26, 26, 26, 26, 26,
     8, 9, 11, 11, 11, 11, 11, 7,
     26, 26, 26, 26, 26, 26, 26, 26,
     26, 24, 25, 26, 26, 26, 26, 20,
     20, 26, 26, 26, 27, 22, 23, 26,
     26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 27, 0, 0, 0, 0, 26,
     0, 0, 0, 0, 0, 0, 0, 7,
     11, 11, 11, 11, 0, 0, 0, 0,
     0, 0, 11, 11, 11, 11, 11, 11,
     6, 16, 0, 0, 6, 6, 6, 6,
     6, 6, 27, 27, 27, 22, 23, 16,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 27, 27, 27, 22, 23, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     28, 28, 28, 28, 28, 28, 28, 28,
     28, 28, 28, 28, 28, 28, 28, 28,
     28, 28, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 3, 3, 3,
     3, 1, 3, 3, 3, 1, 1, 1,
     1, 1, 1, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_21[] = {
     30, 30, 15, 30, 30, 30, 30, 15,
     30, 30, 16, 15, 15, 15, 16, 16,
     15, 15, 15, 16, 30, 15, 30, 30,
     30, 15, 15, 15, 15, 15, 30, 30,
     30, 30, 30, 30, 15, 30, 15, 30,
     15, 30, 15, 15, 15, 15, 30, 16,
     15, 15, 30, 15, 16, 19, 19, 19,
     19, 16, 30, 0, 0, 16, 15, 15,
     27, 27, 27, 27, 27, 15, 16, 16,
     16, 16, 30, 27, 0, 0, 0, 0,
     0, 0, 0, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     5, 5, 5, 5, 5, 5, 5, 5,
     5, 5, 5, 5, 5, 5, 5, 5,
     5, 5, 5, 5, 5, 5, 5, 5,
     5, 5, 5, 5, 5, 5, 5, 5,
     5, 5, 5, 5, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     27, 27, 27, 27, 27, 30, 30, 30,
     30, 30, 27, 27, 30, 30, 30, 30,
     27, 30, 30, 27, 30, 30, 27, 30,
     30, 30, 30, 30, 30, 30, 27, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 27, 27,
     30, 30, 27, 30, 27, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
 };
 
 static const Q_UINT8 ui_22[] = {
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
 };
 
 static const Q_UINT8 ui_23[] = {
     30, 30, 30, 30, 30, 30, 30, 30,
     27, 27, 27, 27, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     27, 27, 30, 30, 30, 30, 30, 30,
     30, 22, 23, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 27, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 22, 23, 26, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_24[] = {
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 0,
 };
 
 static const Q_UINT8 ui_25[] = {
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 27,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 27, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     27, 27, 27, 27, 27, 27, 27, 27,
 };
 
 static const Q_UINT8 ui_26[] = {
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 0, 0, 30, 30,
     0, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 27,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 0, 0,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_27[] = {
     0, 30, 30, 30, 30, 0, 30, 30,
     30, 30, 0, 0, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     0, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 0, 30, 0, 30,
     30, 30, 30, 0, 0, 0, 30, 0,
     30, 30, 30, 30, 30, 30, 30, 0,
     0, 30, 30, 30, 30, 30, 30, 30,
     22, 23, 22, 23, 22, 23, 22, 23,
     22, 23, 22, 23, 22, 23, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 30, 0, 0, 0,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     0, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 22, 23,
     22, 23, 22, 23, 0, 0, 0, 0,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
 };
 
 static const Q_UINT8 ui_28[] = {
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
 };
 
 static const Q_UINT8 ui_29[] = {
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 22, 23, 22, 23, 22,
     23, 22, 23, 22, 23, 22, 23, 22,
     23, 22, 23, 22, 23, 22, 23, 22,
     23, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     22, 23, 22, 23, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 27, 27, 27, 27,
     27, 27, 27, 27, 22, 23, 27, 27,
 };
 
 static const Q_UINT8 ui_2E[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 0, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_2F[] = {
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_30[] = {
     7, 26, 26, 26, 30, 18, 19, 5,
     22, 23, 22, 23, 22, 23, 22, 23,
     22, 23, 30, 30, 22, 23, 22, 23,
     22, 23, 22, 23, 21, 22, 23, 23,
     30, 5, 5, 5, 5, 5, 5, 5,
     5, 5, 1, 1, 1, 1, 1, 1,
     21, 18, 18, 18, 18, 18, 30, 30,
     5, 5, 5, 18, 19, 26, 30, 30,
     0, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     0, 1, 1, 29, 29, 18, 18, 19,
     21, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 20, 18, 18, 18, 19,
 };
 
 static const Q_UINT8 ui_31[] = {
     0, 0, 0, 0, 0, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 0, 0,
     0, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     30, 30, 6, 6, 6, 6, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
 };
 
 static const Q_UINT8 ui_32[] = {
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 0, 0, 0,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 0, 0, 0, 30,
     6, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 6, 6, 6, 6, 6, 6, 6,
     6, 6, 6, 6, 6, 6, 6, 6,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 0, 0, 0, 0,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 0,
 };
 
 static const Q_UINT8 ui_33[] = {
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 0,
     0, 0, 0, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 0, 0,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 0,
 };
 
 static const Q_UINT8 ui_4D[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_9F[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_A4[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 0, 0,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_D7[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_D8[] = {
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
     12, 12, 12, 12, 12, 12, 12, 12,
 };
 
 static const Q_UINT8 ui_E0[] = {
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
 };
 
 static const Q_UINT8 ui_FA[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_FB[] = {
     16, 16, 16, 16, 16, 16, 16, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 16, 16, 16, 16, 16,
     0, 0, 0, 0, 0, 19, 1, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 27, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     19, 19, 19, 19, 19, 0, 19, 0,
     19, 19, 0, 19, 19, 0, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
 };
 
 static const Q_UINT8 ui_FD[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 22, 23,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     0, 0, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 28, 0, 0, 0,
 };
 
 static const Q_UINT8 ui_FE[] = {
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1, 1, 1, 1, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     26, 21, 21, 20, 20, 22, 23, 22,
     23, 22, 23, 22, 23, 22, 23, 22,
     23, 22, 23, 22, 23, 26, 26, 0,
     0, 26, 26, 26, 26, 20, 20, 20,
     26, 26, 26, 0, 26, 26, 26, 26,
     21, 22, 23, 22, 23, 22, 23, 26,
     26, 26, 27, 21, 27, 27, 27, 0,
     26, 28, 26, 26, 0, 0, 0, 0,
     19, 19, 19, 19, 19, 0, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 0, 0, 11,
 };
 
 static const Q_UINT8 ui_FF[] = {
     0, 26, 26, 26, 28, 26, 26, 26,
     22, 23, 26, 27, 26, 21, 26, 26,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 26, 26, 27, 27, 27, 26,
     26, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 22, 26, 23, 29, 20,
     29, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 22, 27, 23, 27, 22,
     23, 26, 22, 23, 26, 20, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     18, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 18, 18,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 0,
     0, 0, 19, 19, 19, 19, 19, 19,
     0, 0, 19, 19, 19, 19, 19, 19,
     0, 0, 19, 19, 19, 19, 19, 19,
     0, 0, 19, 19, 19, 0, 0, 0,
     28, 28, 27, 29, 30, 28, 28, 0,
     30, 27, 27, 27, 27, 30, 30, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 11, 11, 11, 30, 30, 0, 0,
 };
 
 static const Q_UINT8 * const unicode_info[256] = {
     ui_00, ui_01, ui_02, ui_03, ui_04, ui_05, ui_06, ui_07,
     ui_08, ui_09, ui_0A, ui_0B, ui_0C, ui_0D, ui_0E, ui_0F,
     ui_10, ui_11, ui_12, ui_13, ui_14, ui_15, ui_16, ui_17,
     ui_18, ui_08, ui_08, ui_08, ui_08, ui_08, ui_1E, ui_1F,
     ui_20, ui_21, ui_22, ui_23, ui_24, ui_25, ui_26, ui_27,
     ui_28, ui_29, ui_22, ui_08, ui_08, ui_08, ui_2E, ui_2F,
     ui_30, ui_31, ui_32, ui_33, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_4D, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_9F,
     ui_15, ui_15, ui_15, ui_15, ui_A4, ui_08, ui_08, ui_08,
     ui_08, ui_08, ui_08, ui_08, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15,
     ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_15, ui_D7,
     ui_D8, ui_D8, ui_D8, ui_D8, ui_D8, ui_D8, ui_D8, ui_D8,
     ui_E0, ui_E0, ui_E0, ui_E0, ui_E0, ui_E0, ui_E0, ui_E0,
     ui_E0, ui_E0, ui_E0, ui_E0, ui_E0, ui_E0, ui_E0, ui_E0,
     ui_E0, ui_E0, ui_E0, ui_E0, ui_E0, ui_E0, ui_E0, ui_E0,
     ui_E0, ui_15, ui_FA, ui_FB, ui_15, ui_FD, ui_FE, ui_FF,
 };
 // 14848 bytes
 
 static const Q_UINT16 decomposition_map[] = {
     0,
     3, 0x00A0, 0x0020, 0,
     16, 0x00A8, 0x0020, 0x0308, 0,
     9, 0x00AA, 0x0061, 0,
     16, 0x00AF, 0x0020, 0x0304, 0,
     9, 0x00B2, 0x0032, 0,
     9, 0x00B3, 0x0033, 0,
     16, 0x00B4, 0x0020, 0x0301, 0,
     16, 0x00B5, 0x03BC, 0,
     16, 0x00B8, 0x0020, 0x0327, 0,
     9, 0x00B9, 0x0031, 0,
     9, 0x00BA, 0x006F, 0,
     17, 0x00BC, 0x0031, 0x2044, 0x0034, 0,
     17, 0x00BD, 0x0031, 0x2044, 0x0032, 0,
     17, 0x00BE, 0x0033, 0x2044, 0x0034, 0,
     1, 0x00C0, 0x0041, 0x0300, 0,
     1, 0x00C1, 0x0041, 0x0301, 0,
     1, 0x00C2, 0x0041, 0x0302, 0,
     1, 0x00C3, 0x0041, 0x0303, 0,
     1, 0x00C4, 0x0041, 0x0308, 0,
     1, 0x00C5, 0x0041, 0x030A, 0,
     1, 0x00C7, 0x0043, 0x0327, 0,
     1, 0x00C8, 0x0045, 0x0300, 0,
     1, 0x00C9, 0x0045, 0x0301, 0,
     1, 0x00CA, 0x0045, 0x0302, 0,
     1, 0x00CB, 0x0045, 0x0308, 0,
     1, 0x00CC, 0x0049, 0x0300, 0,
     1, 0x00CD, 0x0049, 0x0301, 0,
     1, 0x00CE, 0x0049, 0x0302, 0,
     1, 0x00CF, 0x0049, 0x0308, 0,
     1, 0x00D1, 0x004E, 0x0303, 0,
     1, 0x00D2, 0x004F, 0x0300, 0,
     1, 0x00D3, 0x004F, 0x0301, 0,
     1, 0x00D4, 0x004F, 0x0302, 0,
     1, 0x00D5, 0x004F, 0x0303, 0,
     1, 0x00D6, 0x004F, 0x0308, 0,
     1, 0x00D9, 0x0055, 0x0300, 0,
     1, 0x00DA, 0x0055, 0x0301, 0,
     1, 0x00DB, 0x0055, 0x0302, 0,
     1, 0x00DC, 0x0055, 0x0308, 0,
     1, 0x00DD, 0x0059, 0x0301, 0,
     1, 0x00E0, 0x0061, 0x0300, 0,
     1, 0x00E1, 0x0061, 0x0301, 0,
     1, 0x00E2, 0x0061, 0x0302, 0,
     1, 0x00E3, 0x0061, 0x0303, 0,
     1, 0x00E4, 0x0061, 0x0308, 0,
     1, 0x00E5, 0x0061, 0x030A, 0,
     1, 0x00E7, 0x0063, 0x0327, 0,
     1, 0x00E8, 0x0065, 0x0300, 0,
     1, 0x00E9, 0x0065, 0x0301, 0,
     1, 0x00EA, 0x0065, 0x0302, 0,
     1, 0x00EB, 0x0065, 0x0308, 0,
     1, 0x00EC, 0x0069, 0x0300, 0,
     1, 0x00ED, 0x0069, 0x0301, 0,
     1, 0x00EE, 0x0069, 0x0302, 0,
     1, 0x00EF, 0x0069, 0x0308, 0,
     1, 0x00F1, 0x006E, 0x0303, 0,
     1, 0x00F2, 0x006F, 0x0300, 0,
     1, 0x00F3, 0x006F, 0x0301, 0,
     1, 0x00F4, 0x006F, 0x0302, 0,
     1, 0x00F5, 0x006F, 0x0303, 0,
     1, 0x00F6, 0x006F, 0x0308, 0,
     1, 0x00F9, 0x0075, 0x0300, 0,
     1, 0x00FA, 0x0075, 0x0301, 0,
     1, 0x00FB, 0x0075, 0x0302, 0,
     1, 0x00FC, 0x0075, 0x0308, 0,
     1, 0x00FD, 0x0079, 0x0301, 0,
     1, 0x00FF, 0x0079, 0x0308, 0,
     1, 0x0100, 0x0041, 0x0304, 0,
     1, 0x0101, 0x0061, 0x0304, 0,
     1, 0x0102, 0x0041, 0x0306, 0,
     1, 0x0103, 0x0061, 0x0306, 0,
     1, 0x0104, 0x0041, 0x0328, 0,
     1, 0x0105, 0x0061, 0x0328, 0,
     1, 0x0106, 0x0043, 0x0301, 0,
     1, 0x0107, 0x0063, 0x0301, 0,
     1, 0x0108, 0x0043, 0x0302, 0,
     1, 0x0109, 0x0063, 0x0302, 0,
     1, 0x010A, 0x0043, 0x0307, 0,
     1, 0x010B, 0x0063, 0x0307, 0,
     1, 0x010C, 0x0043, 0x030C, 0,
     1, 0x010D, 0x0063, 0x030C, 0,
     1, 0x010E, 0x0044, 0x030C, 0,
     1, 0x010F, 0x0064, 0x030C, 0,
     1, 0x0112, 0x0045, 0x0304, 0,
     1, 0x0113, 0x0065, 0x0304, 0,
     1, 0x0114, 0x0045, 0x0306, 0,
     1, 0x0115, 0x0065, 0x0306, 0,
     1, 0x0116, 0x0045, 0x0307, 0,
     1, 0x0117, 0x0065, 0x0307, 0,
     1, 0x0118, 0x0045, 0x0328, 0,
     1, 0x0119, 0x0065, 0x0328, 0,
     1, 0x011A, 0x0045, 0x030C, 0,
     1, 0x011B, 0x0065, 0x030C, 0,
     1, 0x011C, 0x0047, 0x0302, 0,
     1, 0x011D, 0x0067, 0x0302, 0,
     1, 0x011E, 0x0047, 0x0306, 0,
     1, 0x011F, 0x0067, 0x0306, 0,
     1, 0x0120, 0x0047, 0x0307, 0,
     1, 0x0121, 0x0067, 0x0307, 0,
     1, 0x0122, 0x0047, 0x0327, 0,
     1, 0x0123, 0x0067, 0x0327, 0,
     1, 0x0124, 0x0048, 0x0302, 0,
     1, 0x0125, 0x0068, 0x0302, 0,
     1, 0x0128, 0x0049, 0x0303, 0,
     1, 0x0129, 0x0069, 0x0303, 0,
     1, 0x012A, 0x0049, 0x0304, 0,
     1, 0x012B, 0x0069, 0x0304, 0,
     1, 0x012C, 0x0049, 0x0306, 0,
     1, 0x012D, 0x0069, 0x0306, 0,
     1, 0x012E, 0x0049, 0x0328, 0,
     1, 0x012F, 0x0069, 0x0328, 0,
     1, 0x0130, 0x0049, 0x0307, 0,
     16, 0x0132, 0x0049, 0x004A, 0,
     16, 0x0133, 0x0069, 0x006A, 0,
     1, 0x0134, 0x004A, 0x0302, 0,
     1, 0x0135, 0x006A, 0x0302, 0,
     1, 0x0136, 0x004B, 0x0327, 0,
     1, 0x0137, 0x006B, 0x0327, 0,
     1, 0x0139, 0x004C, 0x0301, 0,
     1, 0x013A, 0x006C, 0x0301, 0,
     1, 0x013B, 0x004C, 0x0327, 0,
     1, 0x013C, 0x006C, 0x0327, 0,
     1, 0x013D, 0x004C, 0x030C, 0,
     1, 0x013E, 0x006C, 0x030C, 0,
     16, 0x013F, 0x004C, 0x00B7, 0,
     16, 0x0140, 0x006C, 0x00B7, 0,
     1, 0x0143, 0x004E, 0x0301, 0,
     1, 0x0144, 0x006E, 0x0301, 0,
     1, 0x0145, 0x004E, 0x0327, 0,
     1, 0x0146, 0x006E, 0x0327, 0,
     1, 0x0147, 0x004E, 0x030C, 0,
     1, 0x0148, 0x006E, 0x030C, 0,
     16, 0x0149, 0x02BC, 0x006E, 0,
     1, 0x014C, 0x004F, 0x0304, 0,
     1, 0x014D, 0x006F, 0x0304, 0,
     1, 0x014E, 0x004F, 0x0306, 0,
     1, 0x014F, 0x006F, 0x0306, 0,
     1, 0x0150, 0x004F, 0x030B, 0,
     1, 0x0151, 0x006F, 0x030B, 0,
     1, 0x0154, 0x0052, 0x0301, 0,
     1, 0x0155, 0x0072, 0x0301, 0,
     1, 0x0156, 0x0052, 0x0327, 0,
     1, 0x0157, 0x0072, 0x0327, 0,
     1, 0x0158, 0x0052, 0x030C, 0,
     1, 0x0159, 0x0072, 0x030C, 0,
     1, 0x015A, 0x0053, 0x0301, 0,
     1, 0x015B, 0x0073, 0x0301, 0,
     1, 0x015C, 0x0053, 0x0302, 0,
     1, 0x015D, 0x0073, 0x0302, 0,
     1, 0x015E, 0x0053, 0x0327, 0,
     1, 0x015F, 0x0073, 0x0327, 0,
     1, 0x0160, 0x0053, 0x030C, 0,
     1, 0x0161, 0x0073, 0x030C, 0,
     1, 0x0162, 0x0054, 0x0327, 0,
     1, 0x0163, 0x0074, 0x0327, 0,
     1, 0x0164, 0x0054, 0x030C, 0,
     1, 0x0165, 0x0074, 0x030C, 0,
     1, 0x0168, 0x0055, 0x0303, 0,
     1, 0x0169, 0x0075, 0x0303, 0,
     1, 0x016A, 0x0055, 0x0304, 0,
     1, 0x016B, 0x0075, 0x0304, 0,
     1, 0x016C, 0x0055, 0x0306, 0,
     1, 0x016D, 0x0075, 0x0306, 0,
     1, 0x016E, 0x0055, 0x030A, 0,
     1, 0x016F, 0x0075, 0x030A, 0,
     1, 0x0170, 0x0055, 0x030B, 0,
     1, 0x0171, 0x0075, 0x030B, 0,
     1, 0x0172, 0x0055, 0x0328, 0,
     1, 0x0173, 0x0075, 0x0328, 0,
     1, 0x0174, 0x0057, 0x0302, 0,
     1, 0x0175, 0x0077, 0x0302, 0,
     1, 0x0176, 0x0059, 0x0302, 0,
     1, 0x0177, 0x0079, 0x0302, 0,
     1, 0x0178, 0x0059, 0x0308, 0,
     1, 0x0179, 0x005A, 0x0301, 0,
     1, 0x017A, 0x007A, 0x0301, 0,
     1, 0x017B, 0x005A, 0x0307, 0,
     1, 0x017C, 0x007A, 0x0307, 0,
     1, 0x017D, 0x005A, 0x030C, 0,
     1, 0x017E, 0x007A, 0x030C, 0,
     16, 0x017F, 0x0073, 0,
     1, 0x01A0, 0x004F, 0x031B, 0,
     1, 0x01A1, 0x006F, 0x031B, 0,
     1, 0x01AF, 0x0055, 0x031B, 0,
     1, 0x01B0, 0x0075, 0x031B, 0,
     16, 0x01C4, 0x0044, 0x017D, 0,
     16, 0x01C5, 0x0044, 0x017E, 0,
     16, 0x01C6, 0x0064, 0x017E, 0,
     16, 0x01C7, 0x004C, 0x004A, 0,
     16, 0x01C8, 0x004C, 0x006A, 0,
     16, 0x01C9, 0x006C, 0x006A, 0,
     16, 0x01CA, 0x004E, 0x004A, 0,
     16, 0x01CB, 0x004E, 0x006A, 0,
     16, 0x01CC, 0x006E, 0x006A, 0,
     1, 0x01CD, 0x0041, 0x030C, 0,
     1, 0x01CE, 0x0061, 0x030C, 0,
     1, 0x01CF, 0x0049, 0x030C, 0,
     1, 0x01D0, 0x0069, 0x030C, 0,
     1, 0x01D1, 0x004F, 0x030C, 0,
     1, 0x01D2, 0x006F, 0x030C, 0,
     1, 0x01D3, 0x0055, 0x030C, 0,
     1, 0x01D4, 0x0075, 0x030C, 0,
     1, 0x01D5, 0x00DC, 0x0304, 0,
     1, 0x01D6, 0x00FC, 0x0304, 0,
     1, 0x01D7, 0x00DC, 0x0301, 0,
     1, 0x01D8, 0x00FC, 0x0301, 0,
     1, 0x01D9, 0x00DC, 0x030C, 0,
     1, 0x01DA, 0x00FC, 0x030C, 0,
     1, 0x01DB, 0x00DC, 0x0300, 0,
     1, 0x01DC, 0x00FC, 0x0300, 0,
     1, 0x01DE, 0x00C4, 0x0304, 0,
     1, 0x01DF, 0x00E4, 0x0304, 0,
     1, 0x01E0, 0x0226, 0x0304, 0,
     1, 0x01E1, 0x0227, 0x0304, 0,
     1, 0x01E2, 0x00C6, 0x0304, 0,
     1, 0x01E3, 0x00E6, 0x0304, 0,
     1, 0x01E6, 0x0047, 0x030C, 0,
     1, 0x01E7, 0x0067, 0x030C, 0,
     1, 0x01E8, 0x004B, 0x030C, 0,
     1, 0x01E9, 0x006B, 0x030C, 0,
     1, 0x01EA, 0x004F, 0x0328, 0,
     1, 0x01EB, 0x006F, 0x0328, 0,
     1, 0x01EC, 0x01EA, 0x0304, 0,
     1, 0x01ED, 0x01EB, 0x0304, 0,
     1, 0x01EE, 0x01B7, 0x030C, 0,
     1, 0x01EF, 0x0292, 0x030C, 0,
     1, 0x01F0, 0x006A, 0x030C, 0,
     16, 0x01F1, 0x0044, 0x005A, 0,
     16, 0x01F2, 0x0044, 0x007A, 0,
     16, 0x01F3, 0x0064, 0x007A, 0,
     1, 0x01F4, 0x0047, 0x0301, 0,
     1, 0x01F5, 0x0067, 0x0301, 0,
     1, 0x01F8, 0x004E, 0x0300, 0,
     1, 0x01F9, 0x006E, 0x0300, 0,
     1, 0x01FA, 0x00C5, 0x0301, 0,
     1, 0x01FB, 0x00E5, 0x0301, 0,
     1, 0x01FC, 0x00C6, 0x0301, 0,
     1, 0x01FD, 0x00E6, 0x0301, 0,
     1, 0x01FE, 0x00D8, 0x0301, 0,
     1, 0x01FF, 0x00F8, 0x0301, 0,
     1, 0x0200, 0x0041, 0x030F, 0,
     1, 0x0201, 0x0061, 0x030F, 0,
     1, 0x0202, 0x0041, 0x0311, 0,
     1, 0x0203, 0x0061, 0x0311, 0,
     1, 0x0204, 0x0045, 0x030F, 0,
     1, 0x0205, 0x0065, 0x030F, 0,
     1, 0x0206, 0x0045, 0x0311, 0,
     1, 0x0207, 0x0065, 0x0311, 0,
     1, 0x0208, 0x0049, 0x030F, 0,
     1, 0x0209, 0x0069, 0x030F, 0,
     1, 0x020A, 0x0049, 0x0311, 0,
     1, 0x020B, 0x0069, 0x0311, 0,
     1, 0x020C, 0x004F, 0x030F, 0,
     1, 0x020D, 0x006F, 0x030F, 0,
     1, 0x020E, 0x004F, 0x0311, 0,
     1, 0x020F, 0x006F, 0x0311, 0,
     1, 0x0210, 0x0052, 0x030F, 0,
     1, 0x0211, 0x0072, 0x030F, 0,
     1, 0x0212, 0x0052, 0x0311, 0,
     1, 0x0213, 0x0072, 0x0311, 0,
     1, 0x0214, 0x0055, 0x030F, 0,
     1, 0x0215, 0x0075, 0x030F, 0,
     1, 0x0216, 0x0055, 0x0311, 0,
     1, 0x0217, 0x0075, 0x0311, 0,
     1, 0x0218, 0x0053, 0x0326, 0,
     1, 0x0219, 0x0073, 0x0326, 0,
     1, 0x021A, 0x0054, 0x0326, 0,
     1, 0x021B, 0x0074, 0x0326, 0,
     1, 0x021E, 0x0048, 0x030C, 0,
     1, 0x021F, 0x0068, 0x030C, 0,
     1, 0x0226, 0x0041, 0x0307, 0,
     1, 0x0227, 0x0061, 0x0307, 0,
     1, 0x0228, 0x0045, 0x0327, 0,
     1, 0x0229, 0x0065, 0x0327, 0,
     1, 0x022A, 0x00D6, 0x0304, 0,
     1, 0x022B, 0x00F6, 0x0304, 0,
     1, 0x022C, 0x00D5, 0x0304, 0,
     1, 0x022D, 0x00F5, 0x0304, 0,
     1, 0x022E, 0x004F, 0x0307, 0,
     1, 0x022F, 0x006F, 0x0307, 0,
     1, 0x0230, 0x022E, 0x0304, 0,
     1, 0x0231, 0x022F, 0x0304, 0,
     1, 0x0232, 0x0059, 0x0304, 0,
     1, 0x0233, 0x0079, 0x0304, 0,
     9, 0x02B0, 0x0068, 0,
     9, 0x02B1, 0x0266, 0,
     9, 0x02B2, 0x006A, 0,
     9, 0x02B3, 0x0072, 0,
     9, 0x02B4, 0x0279, 0,
     9, 0x02B5, 0x027B, 0,
     9, 0x02B6, 0x0281, 0,
     9, 0x02B7, 0x0077, 0,
     9, 0x02B8, 0x0079, 0,
     16, 0x02D8, 0x0020, 0x0306, 0,
     16, 0x02D9, 0x0020, 0x0307, 0,
     16, 0x02DA, 0x0020, 0x030A, 0,
     16, 0x02DB, 0x0020, 0x0328, 0,
     16, 0x02DC, 0x0020, 0x0303, 0,
     16, 0x02DD, 0x0020, 0x030B, 0,
     9, 0x02E0, 0x0263, 0,
     9, 0x02E1, 0x006C, 0,
     9, 0x02E2, 0x0073, 0,
     9, 0x02E3, 0x0078, 0,
     9, 0x02E4, 0x0295, 0,
     1, 0x0340, 0x0300, 0,
     1, 0x0341, 0x0301, 0,
     1, 0x0343, 0x0313, 0,
     1, 0x0344, 0x0308, 0x0301, 0,
     1, 0x0374, 0x02B9, 0,
     16, 0x037A, 0x0020, 0x0345, 0,
     1, 0x037E, 0x003B, 0,
     16, 0x0384, 0x0020, 0x0301, 0,
     1, 0x0385, 0x00A8, 0x0301, 0,
     1, 0x0386, 0x0391, 0x0301, 0,
     1, 0x0387, 0x00B7, 0,
     1, 0x0388, 0x0395, 0x0301, 0,
     1, 0x0389, 0x0397, 0x0301, 0,
     1, 0x038A, 0x0399, 0x0301, 0,
     1, 0x038C, 0x039F, 0x0301, 0,
     1, 0x038E, 0x03A5, 0x0301, 0,
     1, 0x038F, 0x03A9, 0x0301, 0,
     1, 0x0390, 0x03CA, 0x0301, 0,
     1, 0x03AA, 0x0399, 0x0308, 0,
     1, 0x03AB, 0x03A5, 0x0308, 0,
     1, 0x03AC, 0x03B1, 0x0301, 0,
     1, 0x03AD, 0x03B5, 0x0301, 0,
     1, 0x03AE, 0x03B7, 0x0301, 0,
     1, 0x03AF, 0x03B9, 0x0301, 0,
     1, 0x03B0, 0x03CB, 0x0301, 0,
     1, 0x03CA, 0x03B9, 0x0308, 0,
     1, 0x03CB, 0x03C5, 0x0308, 0,
     1, 0x03CC, 0x03BF, 0x0301, 0,
     1, 0x03CD, 0x03C5, 0x0301, 0,
     1, 0x03CE, 0x03C9, 0x0301, 0,
     16, 0x03D0, 0x03B2, 0,
     16, 0x03D1, 0x03B8, 0,
     16, 0x03D2, 0x03A5, 0,
     1, 0x03D3, 0x03D2, 0x0301, 0,
     1, 0x03D4, 0x03D2, 0x0308, 0,
     16, 0x03D5, 0x03C6, 0,
     16, 0x03D6, 0x03C0, 0,
     16, 0x03F0, 0x03BA, 0,
     16, 0x03F1, 0x03C1, 0,
     16, 0x03F2, 0x03C2, 0,
     16, 0x03F4, 0x0398, 0,
     16, 0x03F5, 0x03B5, 0,
     1, 0x0400, 0x0415, 0x0300, 0,
     1, 0x0401, 0x0415, 0x0308, 0,
     1, 0x0403, 0x0413, 0x0301, 0,
     1, 0x0407, 0x0406, 0x0308, 0,
     1, 0x040C, 0x041A, 0x0301, 0,
     1, 0x040D, 0x0418, 0x0300, 0,
     1, 0x040E, 0x0423, 0x0306, 0,
     1, 0x0419, 0x0418, 0x0306, 0,
     1, 0x0439, 0x0438, 0x0306, 0,
     1, 0x0450, 0x0435, 0x0300, 0,
     1, 0x0451, 0x0435, 0x0308, 0,
     1, 0x0453, 0x0433, 0x0301, 0,
     1, 0x0457, 0x0456, 0x0308, 0,
     1, 0x045C, 0x043A, 0x0301, 0,
     1, 0x045D, 0x0438, 0x0300, 0,
     1, 0x045E, 0x0443, 0x0306, 0,
     1, 0x0476, 0x0474, 0x030F, 0,
     1, 0x0477, 0x0475, 0x030F, 0,
     1, 0x04C1, 0x0416, 0x0306, 0,
     1, 0x04C2, 0x0436, 0x0306, 0,
     1, 0x04D0, 0x0410, 0x0306, 0,
     1, 0x04D1, 0x0430, 0x0306, 0,
     1, 0x04D2, 0x0410, 0x0308, 0,
     1, 0x04D3, 0x0430, 0x0308, 0,
     1, 0x04D6, 0x0415, 0x0306, 0,
     1, 0x04D7, 0x0435, 0x0306, 0,
     1, 0x04DA, 0x04D8, 0x0308, 0,
     1, 0x04DB, 0x04D9, 0x0308, 0,
     1, 0x04DC, 0x0416, 0x0308, 0,
     1, 0x04DD, 0x0436, 0x0308, 0,
     1, 0x04DE, 0x0417, 0x0308, 0,
     1, 0x04DF, 0x0437, 0x0308, 0,
     1, 0x04E2, 0x0418, 0x0304, 0,
     1, 0x04E3, 0x0438, 0x0304, 0,
     1, 0x04E4, 0x0418, 0x0308, 0,
     1, 0x04E5, 0x0438, 0x0308, 0,
     1, 0x04E6, 0x041E, 0x0308, 0,
     1, 0x04E7, 0x043E, 0x0308, 0,
     1, 0x04EA, 0x04E8, 0x0308, 0,
     1, 0x04EB, 0x04E9, 0x0308, 0,
     1, 0x04EC, 0x042D, 0x0308, 0,
     1, 0x04ED, 0x044D, 0x0308, 0,
     1, 0x04EE, 0x0423, 0x0304, 0,
     1, 0x04EF, 0x0443, 0x0304, 0,
     1, 0x04F0, 0x0423, 0x0308, 0,
     1, 0x04F1, 0x0443, 0x0308, 0,
     1, 0x04F2, 0x0423, 0x030B, 0,
     1, 0x04F3, 0x0443, 0x030B, 0,
     1, 0x04F4, 0x0427, 0x0308, 0,
     1, 0x04F5, 0x0447, 0x0308, 0,
     1, 0x04F8, 0x042B, 0x0308, 0,
     1, 0x04F9, 0x044B, 0x0308, 0,
     16, 0x0587, 0x0565, 0x0582, 0,
     1, 0x0622, 0x0627, 0x0653, 0,
     1, 0x0623, 0x0627, 0x0654, 0,
     1, 0x0624, 0x0648, 0x0654, 0,
     1, 0x0625, 0x0627, 0x0655, 0,
     1, 0x0626, 0x064A, 0x0654, 0,
     16, 0x0675, 0x0627, 0x0674, 0,
     16, 0x0676, 0x0648, 0x0674, 0,
     16, 0x0677, 0x06C7, 0x0674, 0,
     16, 0x0678, 0x064A, 0x0674, 0,
     1, 0x06C0, 0x06D5, 0x0654, 0,
     1, 0x06C2, 0x06C1, 0x0654, 0,
     1, 0x06D3, 0x06D2, 0x0654, 0,
     1, 0x0929, 0x0928, 0x093C, 0,
     1, 0x0931, 0x0930, 0x093C, 0,
     1, 0x0934, 0x0933, 0x093C, 0,
     1, 0x0958, 0x0915, 0x093C, 0,
     1, 0x0959, 0x0916, 0x093C, 0,
     1, 0x095A, 0x0917, 0x093C, 0,
     1, 0x095B, 0x091C, 0x093C, 0,
     1, 0x095C, 0x0921, 0x093C, 0,
     1, 0x095D, 0x0922, 0x093C, 0,
     1, 0x095E, 0x092B, 0x093C, 0,
     1, 0x095F, 0x092F, 0x093C, 0,
     1, 0x09CB, 0x09C7, 0x09BE, 0,
     1, 0x09CC, 0x09C7, 0x09D7, 0,
     1, 0x09DC, 0x09A1, 0x09BC, 0,
     1, 0x09DD, 0x09A2, 0x09BC, 0,
     1, 0x09DF, 0x09AF, 0x09BC, 0,
     1, 0x0A33, 0x0A32, 0x0A3C, 0,
     1, 0x0A36, 0x0A38, 0x0A3C, 0,
     1, 0x0A59, 0x0A16, 0x0A3C, 0,
     1, 0x0A5A, 0x0A17, 0x0A3C, 0,
     1, 0x0A5B, 0x0A1C, 0x0A3C, 0,
     1, 0x0A5E, 0x0A2B, 0x0A3C, 0,
     1, 0x0B48, 0x0B47, 0x0B56, 0,
     1, 0x0B4B, 0x0B47, 0x0B3E, 0,
     1, 0x0B4C, 0x0B47, 0x0B57, 0,
     1, 0x0B5C, 0x0B21, 0x0B3C, 0,
     1, 0x0B5D, 0x0B22, 0x0B3C, 0,
     1, 0x0B94, 0x0B92, 0x0BD7, 0,
     1, 0x0BCA, 0x0BC6, 0x0BBE, 0,
     1, 0x0BCB, 0x0BC7, 0x0BBE, 0,
     1, 0x0BCC, 0x0BC6, 0x0BD7, 0,
     1, 0x0C48, 0x0C46, 0x0C56, 0,
     1, 0x0CC0, 0x0CBF, 0x0CD5, 0,
     1, 0x0CC7, 0x0CC6, 0x0CD5, 0,
     1, 0x0CC8, 0x0CC6, 0x0CD6, 0,
     1, 0x0CCA, 0x0CC6, 0x0CC2, 0,
     1, 0x0CCB, 0x0CCA, 0x0CD5, 0,
     1, 0x0D4A, 0x0D46, 0x0D3E, 0,
     1, 0x0D4B, 0x0D47, 0x0D3E, 0,
     1, 0x0D4C, 0x0D46, 0x0D57, 0,
     1, 0x0DDA, 0x0DD9, 0x0DCA, 0,
     1, 0x0DDC, 0x0DD9, 0x0DCF, 0,
     1, 0x0DDD, 0x0DDC, 0x0DCA, 0,
     1, 0x0DDE, 0x0DD9, 0x0DDF, 0,
     16, 0x0E33, 0x0E4D, 0x0E32, 0,
     16, 0x0EB3, 0x0ECD, 0x0EB2, 0,
     16, 0x0EDC, 0x0EAB, 0x0E99, 0,
     16, 0x0EDD, 0x0EAB, 0x0EA1, 0,
     3, 0x0F0C, 0x0F0B, 0,
     1, 0x0F43, 0x0F42, 0x0FB7, 0,
     1, 0x0F4D, 0x0F4C, 0x0FB7, 0,
     1, 0x0F52, 0x0F51, 0x0FB7, 0,
     1, 0x0F57, 0x0F56, 0x0FB7, 0,
     1, 0x0F5C, 0x0F5B, 0x0FB7, 0,
     1, 0x0F69, 0x0F40, 0x0FB5, 0,
     1, 0x0F73, 0x0F71, 0x0F72, 0,
     1, 0x0F75, 0x0F71, 0x0F74, 0,
     1, 0x0F76, 0x0FB2, 0x0F80, 0,
     16, 0x0F77, 0x0FB2, 0x0F81, 0,
     1, 0x0F78, 0x0FB3, 0x0F80, 0,
     16, 0x0F79, 0x0FB3, 0x0F81, 0,
     1, 0x0F81, 0x0F71, 0x0F80, 0,
     1, 0x0F93, 0x0F92, 0x0FB7, 0,
     1, 0x0F9D, 0x0F9C, 0x0FB7, 0,
     1, 0x0FA2, 0x0FA1, 0x0FB7, 0,
     1, 0x0FA7, 0x0FA6, 0x0FB7, 0,
     1, 0x0FAC, 0x0FAB, 0x0FB7, 0,
     1, 0x0FB9, 0x0F90, 0x0FB5, 0,
     1, 0x1026, 0x1025, 0x102E, 0,
     1, 0x1E00, 0x0041, 0x0325, 0,
     1, 0x1E01, 0x0061, 0x0325, 0,
     1, 0x1E02, 0x0042, 0x0307, 0,
     1, 0x1E03, 0x0062, 0x0307, 0,
     1, 0x1E04, 0x0042, 0x0323, 0,
     1, 0x1E05, 0x0062, 0x0323, 0,
     1, 0x1E06, 0x0042, 0x0331, 0,
     1, 0x1E07, 0x0062, 0x0331, 0,
     1, 0x1E08, 0x00C7, 0x0301, 0,
     1, 0x1E09, 0x00E7, 0x0301, 0,
     1, 0x1E0A, 0x0044, 0x0307, 0,
     1, 0x1E0B, 0x0064, 0x0307, 0,
     1, 0x1E0C, 0x0044, 0x0323, 0,
     1, 0x1E0D, 0x0064, 0x0323, 0,
     1, 0x1E0E, 0x0044, 0x0331, 0,
     1, 0x1E0F, 0x0064, 0x0331, 0,
     1, 0x1E10, 0x0044, 0x0327, 0,
     1, 0x1E11, 0x0064, 0x0327, 0,
     1, 0x1E12, 0x0044, 0x032D, 0,
     1, 0x1E13, 0x0064, 0x032D, 0,
     1, 0x1E14, 0x0112, 0x0300, 0,
     1, 0x1E15, 0x0113, 0x0300, 0,
     1, 0x1E16, 0x0112, 0x0301, 0,
     1, 0x1E17, 0x0113, 0x0301, 0,
     1, 0x1E18, 0x0045, 0x032D, 0,
     1, 0x1E19, 0x0065, 0x032D, 0,
     1, 0x1E1A, 0x0045, 0x0330, 0,
     1, 0x1E1B, 0x0065, 0x0330, 0,
     1, 0x1E1C, 0x0228, 0x0306, 0,
     1, 0x1E1D, 0x0229, 0x0306, 0,
     1, 0x1E1E, 0x0046, 0x0307, 0,
     1, 0x1E1F, 0x0066, 0x0307, 0,
     1, 0x1E20, 0x0047, 0x0304, 0,
     1, 0x1E21, 0x0067, 0x0304, 0,
     1, 0x1E22, 0x0048, 0x0307, 0,
     1, 0x1E23, 0x0068, 0x0307, 0,
     1, 0x1E24, 0x0048, 0x0323, 0,
     1, 0x1E25, 0x0068, 0x0323, 0,
     1, 0x1E26, 0x0048, 0x0308, 0,
     1, 0x1E27, 0x0068, 0x0308, 0,
     1, 0x1E28, 0x0048, 0x0327, 0,
     1, 0x1E29, 0x0068, 0x0327, 0,
     1, 0x1E2A, 0x0048, 0x032E, 0,
     1, 0x1E2B, 0x0068, 0x032E, 0,
     1, 0x1E2C, 0x0049, 0x0330, 0,
     1, 0x1E2D, 0x0069, 0x0330, 0,
     1, 0x1E2E, 0x00CF, 0x0301, 0,
     1, 0x1E2F, 0x00EF, 0x0301, 0,
     1, 0x1E30, 0x004B, 0x0301, 0,
     1, 0x1E31, 0x006B, 0x0301, 0,
     1, 0x1E32, 0x004B, 0x0323, 0,
     1, 0x1E33, 0x006B, 0x0323, 0,
     1, 0x1E34, 0x004B, 0x0331, 0,
     1, 0x1E35, 0x006B, 0x0331, 0,
     1, 0x1E36, 0x004C, 0x0323, 0,
     1, 0x1E37, 0x006C, 0x0323, 0,
     1, 0x1E38, 0x1E36, 0x0304, 0,
     1, 0x1E39, 0x1E37, 0x0304, 0,
     1, 0x1E3A, 0x004C, 0x0331, 0,
     1, 0x1E3B, 0x006C, 0x0331, 0,
     1, 0x1E3C, 0x004C, 0x032D, 0,
     1, 0x1E3D, 0x006C, 0x032D, 0,
     1, 0x1E3E, 0x004D, 0x0301, 0,
     1, 0x1E3F, 0x006D, 0x0301, 0,
     1, 0x1E40, 0x004D, 0x0307, 0,
     1, 0x1E41, 0x006D, 0x0307, 0,
     1, 0x1E42, 0x004D, 0x0323, 0,
     1, 0x1E43, 0x006D, 0x0323, 0,
     1, 0x1E44, 0x004E, 0x0307, 0,
     1, 0x1E45, 0x006E, 0x0307, 0,
     1, 0x1E46, 0x004E, 0x0323, 0,
     1, 0x1E47, 0x006E, 0x0323, 0,
     1, 0x1E48, 0x004E, 0x0331, 0,
     1, 0x1E49, 0x006E, 0x0331, 0,
     1, 0x1E4A, 0x004E, 0x032D, 0,
     1, 0x1E4B, 0x006E, 0x032D, 0,
     1, 0x1E4C, 0x00D5, 0x0301, 0,
     1, 0x1E4D, 0x00F5, 0x0301, 0,
     1, 0x1E4E, 0x00D5, 0x0308, 0,
     1, 0x1E4F, 0x00F5, 0x0308, 0,
     1, 0x1E50, 0x014C, 0x0300, 0,
     1, 0x1E51, 0x014D, 0x0300, 0,
     1, 0x1E52, 0x014C, 0x0301, 0,
     1, 0x1E53, 0x014D, 0x0301, 0,
     1, 0x1E54, 0x0050, 0x0301, 0,
     1, 0x1E55, 0x0070, 0x0301, 0,
     1, 0x1E56, 0x0050, 0x0307, 0,
     1, 0x1E57, 0x0070, 0x0307, 0,
     1, 0x1E58, 0x0052, 0x0307, 0,
     1, 0x1E59, 0x0072, 0x0307, 0,
     1, 0x1E5A, 0x0052, 0x0323, 0,
     1, 0x1E5B, 0x0072, 0x0323, 0,
     1, 0x1E5C, 0x1E5A, 0x0304, 0,
     1, 0x1E5D, 0x1E5B, 0x0304, 0,
     1, 0x1E5E, 0x0052, 0x0331, 0,
     1, 0x1E5F, 0x0072, 0x0331, 0,
     1, 0x1E60, 0x0053, 0x0307, 0,
     1, 0x1E61, 0x0073, 0x0307, 0,
     1, 0x1E62, 0x0053, 0x0323, 0,
     1, 0x1E63, 0x0073, 0x0323, 0,
     1, 0x1E64, 0x015A, 0x0307, 0,
     1, 0x1E65, 0x015B, 0x0307, 0,
     1, 0x1E66, 0x0160, 0x0307, 0,
     1, 0x1E67, 0x0161, 0x0307, 0,
     1, 0x1E68, 0x1E62, 0x0307, 0,
     1, 0x1E69, 0x1E63, 0x0307, 0,
     1, 0x1E6A, 0x0054, 0x0307, 0,
     1, 0x1E6B, 0x0074, 0x0307, 0,
     1, 0x1E6C, 0x0054, 0x0323, 0,
     1, 0x1E6D, 0x0074, 0x0323, 0,
     1, 0x1E6E, 0x0054, 0x0331, 0,
     1, 0x1E6F, 0x0074, 0x0331, 0,
     1, 0x1E70, 0x0054, 0x032D, 0,
     1, 0x1E71, 0x0074, 0x032D, 0,
     1, 0x1E72, 0x0055, 0x0324, 0,
     1, 0x1E73, 0x0075, 0x0324, 0,
     1, 0x1E74, 0x0055, 0x0330, 0,
     1, 0x1E75, 0x0075, 0x0330, 0,
     1, 0x1E76, 0x0055, 0x032D, 0,
     1, 0x1E77, 0x0075, 0x032D, 0,
     1, 0x1E78, 0x0168, 0x0301, 0,
     1, 0x1E79, 0x0169, 0x0301, 0,
     1, 0x1E7A, 0x016A, 0x0308, 0,
     1, 0x1E7B, 0x016B, 0x0308, 0,
     1, 0x1E7C, 0x0056, 0x0303, 0,
     1, 0x1E7D, 0x0076, 0x0303, 0,
     1, 0x1E7E, 0x0056, 0x0323, 0,
     1, 0x1E7F, 0x0076, 0x0323, 0,
     1, 0x1E80, 0x0057, 0x0300, 0,
     1, 0x1E81, 0x0077, 0x0300, 0,
     1, 0x1E82, 0x0057, 0x0301, 0,
     1, 0x1E83, 0x0077, 0x0301, 0,
     1, 0x1E84, 0x0057, 0x0308, 0,
     1, 0x1E85, 0x0077, 0x0308, 0,
     1, 0x1E86, 0x0057, 0x0307, 0,
     1, 0x1E87, 0x0077, 0x0307, 0,
     1, 0x1E88, 0x0057, 0x0323, 0,
     1, 0x1E89, 0x0077, 0x0323, 0,
     1, 0x1E8A, 0x0058, 0x0307, 0,
     1, 0x1E8B, 0x0078, 0x0307, 0,
     1, 0x1E8C, 0x0058, 0x0308, 0,
     1, 0x1E8D, 0x0078, 0x0308, 0,
     1, 0x1E8E, 0x0059, 0x0307, 0,
     1, 0x1E8F, 0x0079, 0x0307, 0,
     1, 0x1E90, 0x005A, 0x0302, 0,
     1, 0x1E91, 0x007A, 0x0302, 0,
     1, 0x1E92, 0x005A, 0x0323, 0,
     1, 0x1E93, 0x007A, 0x0323, 0,
     1, 0x1E94, 0x005A, 0x0331, 0,
     1, 0x1E95, 0x007A, 0x0331, 0,
     1, 0x1E96, 0x0068, 0x0331, 0,
     1, 0x1E97, 0x0074, 0x0308, 0,
     1, 0x1E98, 0x0077, 0x030A, 0,
     1, 0x1E99, 0x0079, 0x030A, 0,
     16, 0x1E9A, 0x0061, 0x02BE, 0,
     1, 0x1E9B, 0x017F, 0x0307, 0,
     1, 0x1EA0, 0x0041, 0x0323, 0,
     1, 0x1EA1, 0x0061, 0x0323, 0,
     1, 0x1EA2, 0x0041, 0x0309, 0,
     1, 0x1EA3, 0x0061, 0x0309, 0,
     1, 0x1EA4, 0x00C2, 0x0301, 0,
     1, 0x1EA5, 0x00E2, 0x0301, 0,
     1, 0x1EA6, 0x00C2, 0x0300, 0,
     1, 0x1EA7, 0x00E2, 0x0300, 0,
     1, 0x1EA8, 0x00C2, 0x0309, 0,
     1, 0x1EA9, 0x00E2, 0x0309, 0,
     1, 0x1EAA, 0x00C2, 0x0303, 0,
     1, 0x1EAB, 0x00E2, 0x0303, 0,
     1, 0x1EAC, 0x1EA0, 0x0302, 0,
     1, 0x1EAD, 0x1EA1, 0x0302, 0,
     1, 0x1EAE, 0x0102, 0x0301, 0,
     1, 0x1EAF, 0x0103, 0x0301, 0,
     1, 0x1EB0, 0x0102, 0x0300, 0,
     1, 0x1EB1, 0x0103, 0x0300, 0,
     1, 0x1EB2, 0x0102, 0x0309, 0,
     1, 0x1EB3, 0x0103, 0x0309, 0,
     1, 0x1EB4, 0x0102, 0x0303, 0,
     1, 0x1EB5, 0x0103, 0x0303, 0,
     1, 0x1EB6, 0x1EA0, 0x0306, 0,
     1, 0x1EB7, 0x1EA1, 0x0306, 0,
     1, 0x1EB8, 0x0045, 0x0323, 0,
     1, 0x1EB9, 0x0065, 0x0323, 0,
     1, 0x1EBA, 0x0045, 0x0309, 0,
     1, 0x1EBB, 0x0065, 0x0309, 0,
     1, 0x1EBC, 0x0045, 0x0303, 0,
     1, 0x1EBD, 0x0065, 0x0303, 0,
     1, 0x1EBE, 0x00CA, 0x0301, 0,
     1, 0x1EBF, 0x00EA, 0x0301, 0,
     1, 0x1EC0, 0x00CA, 0x0300, 0,
     1, 0x1EC1, 0x00EA, 0x0300, 0,
     1, 0x1EC2, 0x00CA, 0x0309, 0,
     1, 0x1EC3, 0x00EA, 0x0309, 0,
     1, 0x1EC4, 0x00CA, 0x0303, 0,
     1, 0x1EC5, 0x00EA, 0x0303, 0,
     1, 0x1EC6, 0x1EB8, 0x0302, 0,
     1, 0x1EC7, 0x1EB9, 0x0302, 0,
     1, 0x1EC8, 0x0049, 0x0309, 0,
     1, 0x1EC9, 0x0069, 0x0309, 0,
     1, 0x1ECA, 0x0049, 0x0323, 0,
     1, 0x1ECB, 0x0069, 0x0323, 0,
     1, 0x1ECC, 0x004F, 0x0323, 0,
     1, 0x1ECD, 0x006F, 0x0323, 0,
     1, 0x1ECE, 0x004F, 0x0309, 0,
     1, 0x1ECF, 0x006F, 0x0309, 0,
     1, 0x1ED0, 0x00D4, 0x0301, 0,
     1, 0x1ED1, 0x00F4, 0x0301, 0,
     1, 0x1ED2, 0x00D4, 0x0300, 0,
     1, 0x1ED3, 0x00F4, 0x0300, 0,
     1, 0x1ED4, 0x00D4, 0x0309, 0,
     1, 0x1ED5, 0x00F4, 0x0309, 0,
     1, 0x1ED6, 0x00D4, 0x0303, 0,
     1, 0x1ED7, 0x00F4, 0x0303, 0,
     1, 0x1ED8, 0x1ECC, 0x0302, 0,
     1, 0x1ED9, 0x1ECD, 0x0302, 0,
     1, 0x1EDA, 0x01A0, 0x0301, 0,
     1, 0x1EDB, 0x01A1, 0x0301, 0,
     1, 0x1EDC, 0x01A0, 0x0300, 0,
     1, 0x1EDD, 0x01A1, 0x0300, 0,
     1, 0x1EDE, 0x01A0, 0x0309, 0,
     1, 0x1EDF, 0x01A1, 0x0309, 0,
     1, 0x1EE0, 0x01A0, 0x0303, 0,
     1, 0x1EE1, 0x01A1, 0x0303, 0,
     1, 0x1EE2, 0x01A0, 0x0323, 0,
     1, 0x1EE3, 0x01A1, 0x0323, 0,
     1, 0x1EE4, 0x0055, 0x0323, 0,
     1, 0x1EE5, 0x0075, 0x0323, 0,
     1, 0x1EE6, 0x0055, 0x0309, 0,
     1, 0x1EE7, 0x0075, 0x0309, 0,
     1, 0x1EE8, 0x01AF, 0x0301, 0,
     1, 0x1EE9, 0x01B0, 0x0301, 0,
     1, 0x1EEA, 0x01AF, 0x0300, 0,
     1, 0x1EEB, 0x01B0, 0x0300, 0,
     1, 0x1EEC, 0x01AF, 0x0309, 0,
     1, 0x1EED, 0x01B0, 0x0309, 0,
     1, 0x1EEE, 0x01AF, 0x0303, 0,
     1, 0x1EEF, 0x01B0, 0x0303, 0,
     1, 0x1EF0, 0x01AF, 0x0323, 0,
     1, 0x1EF1, 0x01B0, 0x0323, 0,
     1, 0x1EF2, 0x0059, 0x0300, 0,
     1, 0x1EF3, 0x0079, 0x0300, 0,
     1, 0x1EF4, 0x0059, 0x0323, 0,
     1, 0x1EF5, 0x0079, 0x0323, 0,
     1, 0x1EF6, 0x0059, 0x0309, 0,
     1, 0x1EF7, 0x0079, 0x0309, 0,
     1, 0x1EF8, 0x0059, 0x0303, 0,
     1, 0x1EF9, 0x0079, 0x0303, 0,
     1, 0x1F00, 0x03B1, 0x0313, 0,
     1, 0x1F01, 0x03B1, 0x0314, 0,
     1, 0x1F02, 0x1F00, 0x0300, 0,
     1, 0x1F03, 0x1F01, 0x0300, 0,
     1, 0x1F04, 0x1F00, 0x0301, 0,
     1, 0x1F05, 0x1F01, 0x0301, 0,
     1, 0x1F06, 0x1F00, 0x0342, 0,
     1, 0x1F07, 0x1F01, 0x0342, 0,
     1, 0x1F08, 0x0391, 0x0313, 0,
     1, 0x1F09, 0x0391, 0x0314, 0,
     1, 0x1F0A, 0x1F08, 0x0300, 0,
     1, 0x1F0B, 0x1F09, 0x0300, 0,
     1, 0x1F0C, 0x1F08, 0x0301, 0,
     1, 0x1F0D, 0x1F09, 0x0301, 0,
     1, 0x1F0E, 0x1F08, 0x0342, 0,
     1, 0x1F0F, 0x1F09, 0x0342, 0,
     1, 0x1F10, 0x03B5, 0x0313, 0,
     1, 0x1F11, 0x03B5, 0x0314, 0,
     1, 0x1F12, 0x1F10, 0x0300, 0,
     1, 0x1F13, 0x1F11, 0x0300, 0,
     1, 0x1F14, 0x1F10, 0x0301, 0,
     1, 0x1F15, 0x1F11, 0x0301, 0,
     1, 0x1F18, 0x0395, 0x0313, 0,
     1, 0x1F19, 0x0395, 0x0314, 0,
     1, 0x1F1A, 0x1F18, 0x0300, 0,
     1, 0x1F1B, 0x1F19, 0x0300, 0,
     1, 0x1F1C, 0x1F18, 0x0301, 0,
     1, 0x1F1D, 0x1F19, 0x0301, 0,
     1, 0x1F20, 0x03B7, 0x0313, 0,
     1, 0x1F21, 0x03B7, 0x0314, 0,
     1, 0x1F22, 0x1F20, 0x0300, 0,
     1, 0x1F23, 0x1F21, 0x0300, 0,
     1, 0x1F24, 0x1F20, 0x0301, 0,
     1, 0x1F25, 0x1F21, 0x0301, 0,
     1, 0x1F26, 0x1F20, 0x0342, 0,
     1, 0x1F27, 0x1F21, 0x0342, 0,
     1, 0x1F28, 0x0397, 0x0313, 0,
     1, 0x1F29, 0x0397, 0x0314, 0,
     1, 0x1F2A, 0x1F28, 0x0300, 0,
     1, 0x1F2B, 0x1F29, 0x0300, 0,
     1, 0x1F2C, 0x1F28, 0x0301, 0,
     1, 0x1F2D, 0x1F29, 0x0301, 0,
     1, 0x1F2E, 0x1F28, 0x0342, 0,
     1, 0x1F2F, 0x1F29, 0x0342, 0,
     1, 0x1F30, 0x03B9, 0x0313, 0,
     1, 0x1F31, 0x03B9, 0x0314, 0,
     1, 0x1F32, 0x1F30, 0x0300, 0,
     1, 0x1F33, 0x1F31, 0x0300, 0,
     1, 0x1F34, 0x1F30, 0x0301, 0,
     1, 0x1F35, 0x1F31, 0x0301, 0,
     1, 0x1F36, 0x1F30, 0x0342, 0,
     1, 0x1F37, 0x1F31, 0x0342, 0,
     1, 0x1F38, 0x0399, 0x0313, 0,
     1, 0x1F39, 0x0399, 0x0314, 0,
     1, 0x1F3A, 0x1F38, 0x0300, 0,
     1, 0x1F3B, 0x1F39, 0x0300, 0,
     1, 0x1F3C, 0x1F38, 0x0301, 0,
     1, 0x1F3D, 0x1F39, 0x0301, 0,
     1, 0x1F3E, 0x1F38, 0x0342, 0,
     1, 0x1F3F, 0x1F39, 0x0342, 0,
     1, 0x1F40, 0x03BF, 0x0313, 0,
     1, 0x1F41, 0x03BF, 0x0314, 0,
     1, 0x1F42, 0x1F40, 0x0300, 0,
     1, 0x1F43, 0x1F41, 0x0300, 0,
     1, 0x1F44, 0x1F40, 0x0301, 0,
     1, 0x1F45, 0x1F41, 0x0301, 0,
     1, 0x1F48, 0x039F, 0x0313, 0,
     1, 0x1F49, 0x039F, 0x0314, 0,
     1, 0x1F4A, 0x1F48, 0x0300, 0,
     1, 0x1F4B, 0x1F49, 0x0300, 0,
     1, 0x1F4C, 0x1F48, 0x0301, 0,
     1, 0x1F4D, 0x1F49, 0x0301, 0,
     1, 0x1F50, 0x03C5, 0x0313, 0,
     1, 0x1F51, 0x03C5, 0x0314, 0,
     1, 0x1F52, 0x1F50, 0x0300, 0,
     1, 0x1F53, 0x1F51, 0x0300, 0,
     1, 0x1F54, 0x1F50, 0x0301, 0,
     1, 0x1F55, 0x1F51, 0x0301, 0,
     1, 0x1F56, 0x1F50, 0x0342, 0,
     1, 0x1F57, 0x1F51, 0x0342, 0,
     1, 0x1F59, 0x03A5, 0x0314, 0,
     1, 0x1F5B, 0x1F59, 0x0300, 0,
     1, 0x1F5D, 0x1F59, 0x0301, 0,
     1, 0x1F5F, 0x1F59, 0x0342, 0,
     1, 0x1F60, 0x03C9, 0x0313, 0,
     1, 0x1F61, 0x03C9, 0x0314, 0,
     1, 0x1F62, 0x1F60, 0x0300, 0,
     1, 0x1F63, 0x1F61, 0x0300, 0,
     1, 0x1F64, 0x1F60, 0x0301, 0,
     1, 0x1F65, 0x1F61, 0x0301, 0,
     1, 0x1F66, 0x1F60, 0x0342, 0,
     1, 0x1F67, 0x1F61, 0x0342, 0,
     1, 0x1F68, 0x03A9, 0x0313, 0,
     1, 0x1F69, 0x03A9, 0x0314, 0,
     1, 0x1F6A, 0x1F68, 0x0300, 0,
     1, 0x1F6B, 0x1F69, 0x0300, 0,
     1, 0x1F6C, 0x1F68, 0x0301, 0,
     1, 0x1F6D, 0x1F69, 0x0301, 0,
     1, 0x1F6E, 0x1F68, 0x0342, 0,
     1, 0x1F6F, 0x1F69, 0x0342, 0,
     1, 0x1F70, 0x03B1, 0x0300, 0,
     1, 0x1F71, 0x03AC, 0,
     1, 0x1F72, 0x03B5, 0x0300, 0,
     1, 0x1F73, 0x03AD, 0,
     1, 0x1F74, 0x03B7, 0x0300, 0,
     1, 0x1F75, 0x03AE, 0,
     1, 0x1F76, 0x03B9, 0x0300, 0,
     1, 0x1F77, 0x03AF, 0,
     1, 0x1F78, 0x03BF, 0x0300, 0,
     1, 0x1F79, 0x03CC, 0,
     1, 0x1F7A, 0x03C5, 0x0300, 0,
     1, 0x1F7B, 0x03CD, 0,
     1, 0x1F7C, 0x03C9, 0x0300, 0,
     1, 0x1F7D, 0x03CE, 0,
     1, 0x1F80, 0x1F00, 0x0345, 0,
     1, 0x1F81, 0x1F01, 0x0345, 0,
     1, 0x1F82, 0x1F02, 0x0345, 0,
     1, 0x1F83, 0x1F03, 0x0345, 0,
     1, 0x1F84, 0x1F04, 0x0345, 0,
     1, 0x1F85, 0x1F05, 0x0345, 0,
     1, 0x1F86, 0x1F06, 0x0345, 0,
     1, 0x1F87, 0x1F07, 0x0345, 0,
     1, 0x1F88, 0x1F08, 0x0345, 0,
     1, 0x1F89, 0x1F09, 0x0345, 0,
     1, 0x1F8A, 0x1F0A, 0x0345, 0,
     1, 0x1F8B, 0x1F0B, 0x0345, 0,
     1, 0x1F8C, 0x1F0C, 0x0345, 0,
     1, 0x1F8D, 0x1F0D, 0x0345, 0,
     1, 0x1F8E, 0x1F0E, 0x0345, 0,
     1, 0x1F8F, 0x1F0F, 0x0345, 0,
     1, 0x1F90, 0x1F20, 0x0345, 0,
     1, 0x1F91, 0x1F21, 0x0345, 0,
     1, 0x1F92, 0x1F22, 0x0345, 0,
     1, 0x1F93, 0x1F23, 0x0345, 0,
     1, 0x1F94, 0x1F24, 0x0345, 0,
     1, 0x1F95, 0x1F25, 0x0345, 0,
     1, 0x1F96, 0x1F26, 0x0345, 0,
     1, 0x1F97, 0x1F27, 0x0345, 0,
     1, 0x1F98, 0x1F28, 0x0345, 0,
     1, 0x1F99, 0x1F29, 0x0345, 0,
     1, 0x1F9A, 0x1F2A, 0x0345, 0,
     1, 0x1F9B, 0x1F2B, 0x0345, 0,
     1, 0x1F9C, 0x1F2C, 0x0345, 0,
     1, 0x1F9D, 0x1F2D, 0x0345, 0,
     1, 0x1F9E, 0x1F2E, 0x0345, 0,
     1, 0x1F9F, 0x1F2F, 0x0345, 0,
     1, 0x1FA0, 0x1F60, 0x0345, 0,
     1, 0x1FA1, 0x1F61, 0x0345, 0,
     1, 0x1FA2, 0x1F62, 0x0345, 0,
     1, 0x1FA3, 0x1F63, 0x0345, 0,
     1, 0x1FA4, 0x1F64, 0x0345, 0,
     1, 0x1FA5, 0x1F65, 0x0345, 0,
     1, 0x1FA6, 0x1F66, 0x0345, 0,
     1, 0x1FA7, 0x1F67, 0x0345, 0,
     1, 0x1FA8, 0x1F68, 0x0345, 0,
     1, 0x1FA9, 0x1F69, 0x0345, 0,
     1, 0x1FAA, 0x1F6A, 0x0345, 0,
     1, 0x1FAB, 0x1F6B, 0x0345, 0,
     1, 0x1FAC, 0x1F6C, 0x0345, 0,
     1, 0x1FAD, 0x1F6D, 0x0345, 0,
     1, 0x1FAE, 0x1F6E, 0x0345, 0,
     1, 0x1FAF, 0x1F6F, 0x0345, 0,
     1, 0x1FB0, 0x03B1, 0x0306, 0,
     1, 0x1FB1, 0x03B1, 0x0304, 0,
     1, 0x1FB2, 0x1F70, 0x0345, 0,
     1, 0x1FB3, 0x03B1, 0x0345, 0,
     1, 0x1FB4, 0x03AC, 0x0345, 0,
     1, 0x1FB6, 0x03B1, 0x0342, 0,
     1, 0x1FB7, 0x1FB6, 0x0345, 0,
     1, 0x1FB8, 0x0391, 0x0306, 0,
     1, 0x1FB9, 0x0391, 0x0304, 0,
     1, 0x1FBA, 0x0391, 0x0300, 0,
     1, 0x1FBB, 0x0386, 0,
     1, 0x1FBC, 0x0391, 0x0345, 0,
     16, 0x1FBD, 0x0020, 0x0313, 0,
     1, 0x1FBE, 0x03B9, 0,
     16, 0x1FBF, 0x0020, 0x0313, 0,
     16, 0x1FC0, 0x0020, 0x0342, 0,
     1, 0x1FC1, 0x00A8, 0x0342, 0,
     1, 0x1FC2, 0x1F74, 0x0345, 0,
     1, 0x1FC3, 0x03B7, 0x0345, 0,
     1, 0x1FC4, 0x03AE, 0x0345, 0,
     1, 0x1FC6, 0x03B7, 0x0342, 0,
     1, 0x1FC7, 0x1FC6, 0x0345, 0,
     1, 0x1FC8, 0x0395, 0x0300, 0,
     1, 0x1FC9, 0x0388, 0,
     1, 0x1FCA, 0x0397, 0x0300, 0,
     1, 0x1FCB, 0x0389, 0,
     1, 0x1FCC, 0x0397, 0x0345, 0,
     1, 0x1FCD, 0x1FBF, 0x0300, 0,
     1, 0x1FCE, 0x1FBF, 0x0301, 0,
     1, 0x1FCF, 0x1FBF, 0x0342, 0,
     1, 0x1FD0, 0x03B9, 0x0306, 0,
     1, 0x1FD1, 0x03B9, 0x0304, 0,
     1, 0x1FD2, 0x03CA, 0x0300, 0,
     1, 0x1FD3, 0x0390, 0,
     1, 0x1FD6, 0x03B9, 0x0342, 0,
     1, 0x1FD7, 0x03CA, 0x0342, 0,
     1, 0x1FD8, 0x0399, 0x0306, 0,
     1, 0x1FD9, 0x0399, 0x0304, 0,
     1, 0x1FDA, 0x0399, 0x0300, 0,
     1, 0x1FDB, 0x038A, 0,
     1, 0x1FDD, 0x1FFE, 0x0300, 0,
     1, 0x1FDE, 0x1FFE, 0x0301, 0,
     1, 0x1FDF, 0x1FFE, 0x0342, 0,
     1, 0x1FE0, 0x03C5, 0x0306, 0,
     1, 0x1FE1, 0x03C5, 0x0304, 0,
     1, 0x1FE2, 0x03CB, 0x0300, 0,
     1, 0x1FE3, 0x03B0, 0,
     1, 0x1FE4, 0x03C1, 0x0313, 0,
     1, 0x1FE5, 0x03C1, 0x0314, 0,
     1, 0x1FE6, 0x03C5, 0x0342, 0,
     1, 0x1FE7, 0x03CB, 0x0342, 0,
     1, 0x1FE8, 0x03A5, 0x0306, 0,
     1, 0x1FE9, 0x03A5, 0x0304, 0,
     1, 0x1FEA, 0x03A5, 0x0300, 0,
     1, 0x1FEB, 0x038E, 0,
     1, 0x1FEC, 0x03A1, 0x0314, 0,
     1, 0x1FED, 0x00A8, 0x0300, 0,
     1, 0x1FEE, 0x0385, 0,
     1, 0x1FEF, 0x0060, 0,
     1, 0x1FF2, 0x1F7C, 0x0345, 0,
     1, 0x1FF3, 0x03C9, 0x0345, 0,
     1, 0x1FF4, 0x03CE, 0x0345, 0,
     1, 0x1FF6, 0x03C9, 0x0342, 0,
     1, 0x1FF7, 0x1FF6, 0x0345, 0,
     1, 0x1FF8, 0x039F, 0x0300, 0,
     1, 0x1FF9, 0x038C, 0,
     1, 0x1FFA, 0x03A9, 0x0300, 0,
     1, 0x1FFB, 0x038F, 0,
     1, 0x1FFC, 0x03A9, 0x0345, 0,
     1, 0x1FFD, 0x00B4, 0,
     16, 0x1FFE, 0x0020, 0x0314, 0,
     1, 0x2000, 0x2002, 0,
     1, 0x2001, 0x2003, 0,
     16, 0x2002, 0x0020, 0,
     16, 0x2003, 0x0020, 0,
     16, 0x2004, 0x0020, 0,
     16, 0x2005, 0x0020, 0,
     16, 0x2006, 0x0020, 0,
     3, 0x2007, 0x0020, 0,
     16, 0x2008, 0x0020, 0,
     16, 0x2009, 0x0020, 0,
     16, 0x200A, 0x0020, 0,
     3, 0x2011, 0x2010, 0,
     16, 0x2017, 0x0020, 0x0333, 0,
     16, 0x2024, 0x002E, 0,
     16, 0x2025, 0x002E, 0x002E, 0,
     16, 0x2026, 0x002E, 0x002E, 0x002E, 0,
     3, 0x202F, 0x0020, 0,
     16, 0x2033, 0x2032, 0x2032, 0,
     16, 0x2034, 0x2032, 0x2032, 0x2032, 0,
     16, 0x2036, 0x2035, 0x2035, 0,
     16, 0x2037, 0x2035, 0x2035, 0x2035, 0,
     16, 0x203C, 0x0021, 0x0021, 0,
     16, 0x203E, 0x0020, 0x0305, 0,
     16, 0x2047, 0x003F, 0x003F, 0,
     16, 0x2048, 0x003F, 0x0021, 0,
     16, 0x2049, 0x0021, 0x003F, 0,
     16, 0x2057, 0x2032, 0x2032, 0x2032, 0x2032, 0,
     16, 0x205F, 0x0020, 0,
     9, 0x2070, 0x0030, 0,
     9, 0x2071, 0x0069, 0,
     9, 0x2074, 0x0034, 0,
     9, 0x2075, 0x0035, 0,
     9, 0x2076, 0x0036, 0,
     9, 0x2077, 0x0037, 0,
     9, 0x2078, 0x0038, 0,
     9, 0x2079, 0x0039, 0,
     9, 0x207A, 0x002B, 0,
     9, 0x207B, 0x2212, 0,
     9, 0x207C, 0x003D, 0,
     9, 0x207D, 0x0028, 0,
     9, 0x207E, 0x0029, 0,
     9, 0x207F, 0x006E, 0,
     10, 0x2080, 0x0030, 0,
     10, 0x2081, 0x0031, 0,
     10, 0x2082, 0x0032, 0,
     10, 0x2083, 0x0033, 0,
     10, 0x2084, 0x0034, 0,
     10, 0x2085, 0x0035, 0,
     10, 0x2086, 0x0036, 0,
     10, 0x2087, 0x0037, 0,
     10, 0x2088, 0x0038, 0,
     10, 0x2089, 0x0039, 0,
     10, 0x208A, 0x002B, 0,
     10, 0x208B, 0x2212, 0,
     10, 0x208C, 0x003D, 0,
     10, 0x208D, 0x0028, 0,
     10, 0x208E, 0x0029, 0,
     16, 0x20A8, 0x0052, 0x0073, 0,
     16, 0x2100, 0x0061, 0x002F, 0x0063, 0,
     16, 0x2101, 0x0061, 0x002F, 0x0073, 0,
     2, 0x2102, 0x0043, 0,
     16, 0x2103, 0x00B0, 0x0043, 0,
     16, 0x2105, 0x0063, 0x002F, 0x006F, 0,
     16, 0x2106, 0x0063, 0x002F, 0x0075, 0,
     16, 0x2107, 0x0190, 0,
     16, 0x2109, 0x00B0, 0x0046, 0,
     2, 0x210A, 0x0067, 0,
     2, 0x210B, 0x0048, 0,
     2, 0x210C, 0x0048, 0,
     2, 0x210D, 0x0048, 0,
     2, 0x210E, 0x0068, 0,
     2, 0x210F, 0x0127, 0,
     2, 0x2110, 0x0049, 0,
     2, 0x2111, 0x0049, 0,
     2, 0x2112, 0x004C, 0,
     2, 0x2113, 0x006C, 0,
     2, 0x2115, 0x004E, 0,
     16, 0x2116, 0x004E, 0x006F, 0,
     2, 0x2119, 0x0050, 0,
     2, 0x211A, 0x0051, 0,
     2, 0x211B, 0x0052, 0,
     2, 0x211C, 0x0052, 0,
     2, 0x211D, 0x0052, 0,
     9, 0x2120, 0x0053, 0x004D, 0,
     16, 0x2121, 0x0054, 0x0045, 0x004C, 0,
     9, 0x2122, 0x0054, 0x004D, 0,
     2, 0x2124, 0x005A, 0,
     1, 0x2126, 0x03A9, 0,
     2, 0x2128, 0x005A, 0,
     1, 0x212A, 0x004B, 0,
     1, 0x212B, 0x00C5, 0,
     2, 0x212C, 0x0042, 0,
     2, 0x212D, 0x0043, 0,
     2, 0x212F, 0x0065, 0,
     2, 0x2130, 0x0045, 0,
     2, 0x2131, 0x0046, 0,
     2, 0x2133, 0x004D, 0,
     2, 0x2134, 0x006F, 0,
     16, 0x2135, 0x05D0, 0,
     16, 0x2136, 0x05D1, 0,
     16, 0x2137, 0x05D2, 0,
     16, 0x2138, 0x05D3, 0,
     2, 0x2139, 0x0069, 0,
     2, 0x213D, 0x03B3, 0,
     2, 0x213E, 0x0393, 0,
     2, 0x213F, 0x03A0, 0,
     2, 0x2140, 0x2211, 0,
     2, 0x2145, 0x0044, 0,
     2, 0x2146, 0x0064, 0,
     2, 0x2147, 0x0065, 0,
     2, 0x2148, 0x0069, 0,
     2, 0x2149, 0x006A, 0,
     17, 0x2153, 0x0031, 0x2044, 0x0033, 0,
     17, 0x2154, 0x0032, 0x2044, 0x0033, 0,
     17, 0x2155, 0x0031, 0x2044, 0x0035, 0,
     17, 0x2156, 0x0032, 0x2044, 0x0035, 0,
     17, 0x2157, 0x0033, 0x2044, 0x0035, 0,
     17, 0x2158, 0x0034, 0x2044, 0x0035, 0,
     17, 0x2159, 0x0031, 0x2044, 0x0036, 0,
     17, 0x215A, 0x0035, 0x2044, 0x0036, 0,
     17, 0x215B, 0x0031, 0x2044, 0x0038, 0,
     17, 0x215C, 0x0033, 0x2044, 0x0038, 0,
     17, 0x215D, 0x0035, 0x2044, 0x0038, 0,
     17, 0x215E, 0x0037, 0x2044, 0x0038, 0,
     17, 0x215F, 0x0031, 0x2044, 0,
     16, 0x2160, 0x0049, 0,
     16, 0x2161, 0x0049, 0x0049, 0,
     16, 0x2162, 0x0049, 0x0049, 0x0049, 0,
     16, 0x2163, 0x0049, 0x0056, 0,
     16, 0x2164, 0x0056, 0,
     16, 0x2165, 0x0056, 0x0049, 0,
     16, 0x2166, 0x0056, 0x0049, 0x0049, 0,
     16, 0x2167, 0x0056, 0x0049, 0x0049, 0x0049, 0,
     16, 0x2168, 0x0049, 0x0058, 0,
     16, 0x2169, 0x0058, 0,
     16, 0x216A, 0x0058, 0x0049, 0,
     16, 0x216B, 0x0058, 0x0049, 0x0049, 0,
     16, 0x216C, 0x004C, 0,
     16, 0x216D, 0x0043, 0,
     16, 0x216E, 0x0044, 0,
     16, 0x216F, 0x004D, 0,
     16, 0x2170, 0x0069, 0,
     16, 0x2171, 0x0069, 0x0069, 0,
     16, 0x2172, 0x0069, 0x0069, 0x0069, 0,
     16, 0x2173, 0x0069, 0x0076, 0,
     16, 0x2174, 0x0076, 0,
     16, 0x2175, 0x0076, 0x0069, 0,
     16, 0x2176, 0x0076, 0x0069, 0x0069, 0,
     16, 0x2177, 0x0076, 0x0069, 0x0069, 0x0069, 0,
     16, 0x2178, 0x0069, 0x0078, 0,
     16, 0x2179, 0x0078, 0,
     16, 0x217A, 0x0078, 0x0069, 0,
     16, 0x217B, 0x0078, 0x0069, 0x0069, 0,
     16, 0x217C, 0x006C, 0,
     16, 0x217D, 0x0063, 0,
     16, 0x217E, 0x0064, 0,
     16, 0x217F, 0x006D, 0,
     1, 0x219A, 0x2190, 0x0338, 0,
     1, 0x219B, 0x2192, 0x0338, 0,
     1, 0x21AE, 0x2194, 0x0338, 0,
     1, 0x21CD, 0x21D0, 0x0338, 0,
     1, 0x21CE, 0x21D4, 0x0338, 0,
     1, 0x21CF, 0x21D2, 0x0338, 0,
     1, 0x2204, 0x2203, 0x0338, 0,
     1, 0x2209, 0x2208, 0x0338, 0,
     1, 0x220C, 0x220B, 0x0338, 0,
     1, 0x2224, 0x2223, 0x0338, 0,
     1, 0x2226, 0x2225, 0x0338, 0,
     16, 0x222C, 0x222B, 0x222B, 0,
     16, 0x222D, 0x222B, 0x222B, 0x222B, 0,
     16, 0x222F, 0x222E, 0x222E, 0,
     16, 0x2230, 0x222E, 0x222E, 0x222E, 0,
     1, 0x2241, 0x223C, 0x0338, 0,
     1, 0x2244, 0x2243, 0x0338, 0,
     1, 0x2247, 0x2245, 0x0338, 0,
     1, 0x2249, 0x2248, 0x0338, 0,
     1, 0x2260, 0x003D, 0x0338, 0,
     1, 0x2262, 0x2261, 0x0338, 0,
     1, 0x226D, 0x224D, 0x0338, 0,
     1, 0x226E, 0x003C, 0x0338, 0,
     1, 0x226F, 0x003E, 0x0338, 0,
     1, 0x2270, 0x2264, 0x0338, 0,
     1, 0x2271, 0x2265, 0x0338, 0,
     1, 0x2274, 0x2272, 0x0338, 0,
     1, 0x2275, 0x2273, 0x0338, 0,
     1, 0x2278, 0x2276, 0x0338, 0,
     1, 0x2279, 0x2277, 0x0338, 0,
     1, 0x2280, 0x227A, 0x0338, 0,
     1, 0x2281, 0x227B, 0x0338, 0,
     1, 0x2284, 0x2282, 0x0338, 0,
     1, 0x2285, 0x2283, 0x0338, 0,
     1, 0x2288, 0x2286, 0x0338, 0,
     1, 0x2289, 0x2287, 0x0338, 0,
     1, 0x22AC, 0x22A2, 0x0338, 0,
     1, 0x22AD, 0x22A8, 0x0338, 0,
     1, 0x22AE, 0x22A9, 0x0338, 0,
     1, 0x22AF, 0x22AB, 0x0338, 0,
     1, 0x22E0, 0x227C, 0x0338, 0,
     1, 0x22E1, 0x227D, 0x0338, 0,
     1, 0x22E2, 0x2291, 0x0338, 0,
     1, 0x22E3, 0x2292, 0x0338, 0,
     1, 0x22EA, 0x22B2, 0x0338, 0,
     1, 0x22EB, 0x22B3, 0x0338, 0,
     1, 0x22EC, 0x22B4, 0x0338, 0,
     1, 0x22ED, 0x22B5, 0x0338, 0,
     1, 0x2329, 0x3008, 0,
     1, 0x232A, 0x3009, 0,
     8, 0x2460, 0x0031, 0,
     8, 0x2461, 0x0032, 0,
     8, 0x2462, 0x0033, 0,
     8, 0x2463, 0x0034, 0,
     8, 0x2464, 0x0035, 0,
     8, 0x2465, 0x0036, 0,
     8, 0x2466, 0x0037, 0,
     8, 0x2467, 0x0038, 0,
     8, 0x2468, 0x0039, 0,
     8, 0x2469, 0x0031, 0x0030, 0,
     8, 0x246A, 0x0031, 0x0031, 0,
     8, 0x246B, 0x0031, 0x0032, 0,
     8, 0x246C, 0x0031, 0x0033, 0,
     8, 0x246D, 0x0031, 0x0034, 0,
     8, 0x246E, 0x0031, 0x0035, 0,
     8, 0x246F, 0x0031, 0x0036, 0,
     8, 0x2470, 0x0031, 0x0037, 0,
     8, 0x2471, 0x0031, 0x0038, 0,
     8, 0x2472, 0x0031, 0x0039, 0,
     8, 0x2473, 0x0032, 0x0030, 0,
     16, 0x2474, 0x0028, 0x0031, 0x0029, 0,
     16, 0x2475, 0x0028, 0x0032, 0x0029, 0,
     16, 0x2476, 0x0028, 0x0033, 0x0029, 0,
     16, 0x2477, 0x0028, 0x0034, 0x0029, 0,
     16, 0x2478, 0x0028, 0x0035, 0x0029, 0,
     16, 0x2479, 0x0028, 0x0036, 0x0029, 0,
     16, 0x247A, 0x0028, 0x0037, 0x0029, 0,
     16, 0x247B, 0x0028, 0x0038, 0x0029, 0,
     16, 0x247C, 0x0028, 0x0039, 0x0029, 0,
     16, 0x247D, 0x0028, 0x0031, 0x0030, 0x0029, 0,
     16, 0x247E, 0x0028, 0x0031, 0x0031, 0x0029, 0,
     16, 0x247F, 0x0028, 0x0031, 0x0032, 0x0029, 0,
     16, 0x2480, 0x0028, 0x0031, 0x0033, 0x0029, 0,
     16, 0x2481, 0x0028, 0x0031, 0x0034, 0x0029, 0,
     16, 0x2482, 0x0028, 0x0031, 0x0035, 0x0029, 0,
     16, 0x2483, 0x0028, 0x0031, 0x0036, 0x0029, 0,
     16, 0x2484, 0x0028, 0x0031, 0x0037, 0x0029, 0,
     16, 0x2485, 0x0028, 0x0031, 0x0038, 0x0029, 0,
     16, 0x2486, 0x0028, 0x0031, 0x0039, 0x0029, 0,
     16, 0x2487, 0x0028, 0x0032, 0x0030, 0x0029, 0,
     16, 0x2488, 0x0031, 0x002E, 0,
     16, 0x2489, 0x0032, 0x002E, 0,
     16, 0x248A, 0x0033, 0x002E, 0,
     16, 0x248B, 0x0034, 0x002E, 0,
     16, 0x248C, 0x0035, 0x002E, 0,
     16, 0x248D, 0x0036, 0x002E, 0,
     16, 0x248E, 0x0037, 0x002E, 0,
     16, 0x248F, 0x0038, 0x002E, 0,
     16, 0x2490, 0x0039, 0x002E, 0,
     16, 0x2491, 0x0031, 0x0030, 0x002E, 0,
     16, 0x2492, 0x0031, 0x0031, 0x002E, 0,
     16, 0x2493, 0x0031, 0x0032, 0x002E, 0,
     16, 0x2494, 0x0031, 0x0033, 0x002E, 0,
     16, 0x2495, 0x0031, 0x0034, 0x002E, 0,
     16, 0x2496, 0x0031, 0x0035, 0x002E, 0,
     16, 0x2497, 0x0031, 0x0036, 0x002E, 0,
     16, 0x2498, 0x0031, 0x0037, 0x002E, 0,
     16, 0x2499, 0x0031, 0x0038, 0x002E, 0,
     16, 0x249A, 0x0031, 0x0039, 0x002E, 0,
     16, 0x249B, 0x0032, 0x0030, 0x002E, 0,
     16, 0x249C, 0x0028, 0x0061, 0x0029, 0,
     16, 0x249D, 0x0028, 0x0062, 0x0029, 0,
     16, 0x249E, 0x0028, 0x0063, 0x0029, 0,
     16, 0x249F, 0x0028, 0x0064, 0x0029, 0,
     16, 0x24A0, 0x0028, 0x0065, 0x0029, 0,
     16, 0x24A1, 0x0028, 0x0066, 0x0029, 0,
     16, 0x24A2, 0x0028, 0x0067, 0x0029, 0,
     16, 0x24A3, 0x0028, 0x0068, 0x0029, 0,
     16, 0x24A4, 0x0028, 0x0069, 0x0029, 0,
     16, 0x24A5, 0x0028, 0x006A, 0x0029, 0,
     16, 0x24A6, 0x0028, 0x006B, 0x0029, 0,
     16, 0x24A7, 0x0028, 0x006C, 0x0029, 0,
     16, 0x24A8, 0x0028, 0x006D, 0x0029, 0,
     16, 0x24A9, 0x0028, 0x006E, 0x0029, 0,
     16, 0x24AA, 0x0028, 0x006F, 0x0029, 0,
     16, 0x24AB, 0x0028, 0x0070, 0x0029, 0,
     16, 0x24AC, 0x0028, 0x0071, 0x0029, 0,
     16, 0x24AD, 0x0028, 0x0072, 0x0029, 0,
     16, 0x24AE, 0x0028, 0x0073, 0x0029, 0,
     16, 0x24AF, 0x0028, 0x0074, 0x0029, 0,
     16, 0x24B0, 0x0028, 0x0075, 0x0029, 0,
     16, 0x24B1, 0x0028, 0x0076, 0x0029, 0,
     16, 0x24B2, 0x0028, 0x0077, 0x0029, 0,
     16, 0x24B3, 0x0028, 0x0078, 0x0029, 0,
     16, 0x24B4, 0x0028, 0x0079, 0x0029, 0,
     16, 0x24B5, 0x0028, 0x007A, 0x0029, 0,
     8, 0x24B6, 0x0041, 0,
     8, 0x24B7, 0x0042, 0,
     8, 0x24B8, 0x0043, 0,
     8, 0x24B9, 0x0044, 0,
     8, 0x24BA, 0x0045, 0,
     8, 0x24BB, 0x0046, 0,
     8, 0x24BC, 0x0047, 0,
     8, 0x24BD, 0x0048, 0,
     8, 0x24BE, 0x0049, 0,
     8, 0x24BF, 0x004A, 0,
     8, 0x24C0, 0x004B, 0,
     8, 0x24C1, 0x004C, 0,
     8, 0x24C2, 0x004D, 0,
     8, 0x24C3, 0x004E, 0,
     8, 0x24C4, 0x004F, 0,
     8, 0x24C5, 0x0050, 0,
     8, 0x24C6, 0x0051, 0,
     8, 0x24C7, 0x0052, 0,
     8, 0x24C8, 0x0053, 0,
     8, 0x24C9, 0x0054, 0,
     8, 0x24CA, 0x0055, 0,
     8, 0x24CB, 0x0056, 0,
     8, 0x24CC, 0x0057, 0,
     8, 0x24CD, 0x0058, 0,
     8, 0x24CE, 0x0059, 0,
     8, 0x24CF, 0x005A, 0,
     8, 0x24D0, 0x0061, 0,
     8, 0x24D1, 0x0062, 0,
     8, 0x24D2, 0x0063, 0,
     8, 0x24D3, 0x0064, 0,
     8, 0x24D4, 0x0065, 0,
     8, 0x24D5, 0x0066, 0,
     8, 0x24D6, 0x0067, 0,
     8, 0x24D7, 0x0068, 0,
     8, 0x24D8, 0x0069, 0,
     8, 0x24D9, 0x006A, 0,
     8, 0x24DA, 0x006B, 0,
     8, 0x24DB, 0x006C, 0,
     8, 0x24DC, 0x006D, 0,
     8, 0x24DD, 0x006E, 0,
     8, 0x24DE, 0x006F, 0,
     8, 0x24DF, 0x0070, 0,
     8, 0x24E0, 0x0071, 0,
     8, 0x24E1, 0x0072, 0,
     8, 0x24E2, 0x0073, 0,
     8, 0x24E3, 0x0074, 0,
     8, 0x24E4, 0x0075, 0,
     8, 0x24E5, 0x0076, 0,
     8, 0x24E6, 0x0077, 0,
     8, 0x24E7, 0x0078, 0,
     8, 0x24E8, 0x0079, 0,
     8, 0x24E9, 0x007A, 0,
     8, 0x24EA, 0x0030, 0,
     16, 0x2A0C, 0x222B, 0x222B, 0x222B, 0x222B, 0,
     16, 0x2A74, 0x003A, 0x003A, 0x003D, 0,
     16, 0x2A75, 0x003D, 0x003D, 0,
     16, 0x2A76, 0x003D, 0x003D, 0x003D, 0,
     1, 0x2ADC, 0x2ADD, 0x0338, 0,
     16, 0x2E9F, 0x6BCD, 0,
     16, 0x2EF3, 0x9F9F, 0,
     16, 0x2F00, 0x4E00, 0,
     16, 0x2F01, 0x4E28, 0,
     16, 0x2F02, 0x4E36, 0,
     16, 0x2F03, 0x4E3F, 0,
     16, 0x2F04, 0x4E59, 0,
     16, 0x2F05, 0x4E85, 0,
     16, 0x2F06, 0x4E8C, 0,
     16, 0x2F07, 0x4EA0, 0,
     16, 0x2F08, 0x4EBA, 0,
     16, 0x2F09, 0x513F, 0,
     16, 0x2F0A, 0x5165, 0,
     16, 0x2F0B, 0x516B, 0,
     16, 0x2F0C, 0x5182, 0,
     16, 0x2F0D, 0x5196, 0,
     16, 0x2F0E, 0x51AB, 0,
     16, 0x2F0F, 0x51E0, 0,
     16, 0x2F10, 0x51F5, 0,
     16, 0x2F11, 0x5200, 0,
     16, 0x2F12, 0x529B, 0,
     16, 0x2F13, 0x52F9, 0,
     16, 0x2F14, 0x5315, 0,
     16, 0x2F15, 0x531A, 0,
     16, 0x2F16, 0x5338, 0,
     16, 0x2F17, 0x5341, 0,
     16, 0x2F18, 0x535C, 0,
     16, 0x2F19, 0x5369, 0,
     16, 0x2F1A, 0x5382, 0,
     16, 0x2F1B, 0x53B6, 0,
     16, 0x2F1C, 0x53C8, 0,
     16, 0x2F1D, 0x53E3, 0,
     16, 0x2F1E, 0x56D7, 0,
     16, 0x2F1F, 0x571F, 0,
     16, 0x2F20, 0x58EB, 0,
     16, 0x2F21, 0x5902, 0,
     16, 0x2F22, 0x590A, 0,
     16, 0x2F23, 0x5915, 0,
     16, 0x2F24, 0x5927, 0,
     16, 0x2F25, 0x5973, 0,
     16, 0x2F26, 0x5B50, 0,
     16, 0x2F27, 0x5B80, 0,
     16, 0x2F28, 0x5BF8, 0,
     16, 0x2F29, 0x5C0F, 0,
     16, 0x2F2A, 0x5C22, 0,
     16, 0x2F2B, 0x5C38, 0,
     16, 0x2F2C, 0x5C6E, 0,
     16, 0x2F2D, 0x5C71, 0,
     16, 0x2F2E, 0x5DDB, 0,
     16, 0x2F2F, 0x5DE5, 0,
     16, 0x2F30, 0x5DF1, 0,
     16, 0x2F31, 0x5DFE, 0,
     16, 0x2F32, 0x5E72, 0,
     16, 0x2F33, 0x5E7A, 0,
     16, 0x2F34, 0x5E7F, 0,
     16, 0x2F35, 0x5EF4, 0,
     16, 0x2F36, 0x5EFE, 0,
     16, 0x2F37, 0x5F0B, 0,
     16, 0x2F38, 0x5F13, 0,
     16, 0x2F39, 0x5F50, 0,
     16, 0x2F3A, 0x5F61, 0,
     16, 0x2F3B, 0x5F73, 0,
     16, 0x2F3C, 0x5FC3, 0,
     16, 0x2F3D, 0x6208, 0,
     16, 0x2F3E, 0x6236, 0,
     16, 0x2F3F, 0x624B, 0,
     16, 0x2F40, 0x652F, 0,
     16, 0x2F41, 0x6534, 0,
     16, 0x2F42, 0x6587, 0,
     16, 0x2F43, 0x6597, 0,
     16, 0x2F44, 0x65A4, 0,
     16, 0x2F45, 0x65B9, 0,
     16, 0x2F46, 0x65E0, 0,
     16, 0x2F47, 0x65E5, 0,
     16, 0x2F48, 0x66F0, 0,
     16, 0x2F49, 0x6708, 0,
     16, 0x2F4A, 0x6728, 0,
     16, 0x2F4B, 0x6B20, 0,
     16, 0x2F4C, 0x6B62, 0,
     16, 0x2F4D, 0x6B79, 0,
     16, 0x2F4E, 0x6BB3, 0,
     16, 0x2F4F, 0x6BCB, 0,
     16, 0x2F50, 0x6BD4, 0,
     16, 0x2F51, 0x6BDB, 0,
     16, 0x2F52, 0x6C0F, 0,
     16, 0x2F53, 0x6C14, 0,
     16, 0x2F54, 0x6C34, 0,
     16, 0x2F55, 0x706B, 0,
     16, 0x2F56, 0x722A, 0,
     16, 0x2F57, 0x7236, 0,
     16, 0x2F58, 0x723B, 0,
     16, 0x2F59, 0x723F, 0,
     16, 0x2F5A, 0x7247, 0,
     16, 0x2F5B, 0x7259, 0,
     16, 0x2F5C, 0x725B, 0,
     16, 0x2F5D, 0x72AC, 0,
     16, 0x2F5E, 0x7384, 0,
     16, 0x2F5F, 0x7389, 0,
     16, 0x2F60, 0x74DC, 0,
     16, 0x2F61, 0x74E6, 0,
     16, 0x2F62, 0x7518, 0,
     16, 0x2F63, 0x751F, 0,
     16, 0x2F64, 0x7528, 0,
     16, 0x2F65, 0x7530, 0,
     16, 0x2F66, 0x758B, 0,
     16, 0x2F67, 0x7592, 0,
     16, 0x2F68, 0x7676, 0,
     16, 0x2F69, 0x767D, 0,
     16, 0x2F6A, 0x76AE, 0,
     16, 0x2F6B, 0x76BF, 0,
     16, 0x2F6C, 0x76EE, 0,
     16, 0x2F6D, 0x77DB, 0,
     16, 0x2F6E, 0x77E2, 0,
     16, 0x2F6F, 0x77F3, 0,
     16, 0x2F70, 0x793A, 0,
     16, 0x2F71, 0x79B8, 0,
     16, 0x2F72, 0x79BE, 0,
     16, 0x2F73, 0x7A74, 0,
     16, 0x2F74, 0x7ACB, 0,
     16, 0x2F75, 0x7AF9, 0,
     16, 0x2F76, 0x7C73, 0,
     16, 0x2F77, 0x7CF8, 0,
     16, 0x2F78, 0x7F36, 0,
     16, 0x2F79, 0x7F51, 0,
     16, 0x2F7A, 0x7F8A, 0,
     16, 0x2F7B, 0x7FBD, 0,
     16, 0x2F7C, 0x8001, 0,
     16, 0x2F7D, 0x800C, 0,
     16, 0x2F7E, 0x8012, 0,
     16, 0x2F7F, 0x8033, 0,
     16, 0x2F80, 0x807F, 0,
     16, 0x2F81, 0x8089, 0,
     16, 0x2F82, 0x81E3, 0,
     16, 0x2F83, 0x81EA, 0,
     16, 0x2F84, 0x81F3, 0,
     16, 0x2F85, 0x81FC, 0,
     16, 0x2F86, 0x820C, 0,
     16, 0x2F87, 0x821B, 0,
     16, 0x2F88, 0x821F, 0,
     16, 0x2F89, 0x826E, 0,
     16, 0x2F8A, 0x8272, 0,
     16, 0x2F8B, 0x8278, 0,
     16, 0x2F8C, 0x864D, 0,
     16, 0x2F8D, 0x866B, 0,
     16, 0x2F8E, 0x8840, 0,
     16, 0x2F8F, 0x884C, 0,
     16, 0x2F90, 0x8863, 0,
     16, 0x2F91, 0x897E, 0,
     16, 0x2F92, 0x898B, 0,
     16, 0x2F93, 0x89D2, 0,
     16, 0x2F94, 0x8A00, 0,
     16, 0x2F95, 0x8C37, 0,
     16, 0x2F96, 0x8C46, 0,
     16, 0x2F97, 0x8C55, 0,
     16, 0x2F98, 0x8C78, 0,
     16, 0x2F99, 0x8C9D, 0,
     16, 0x2F9A, 0x8D64, 0,
     16, 0x2F9B, 0x8D70, 0,
     16, 0x2F9C, 0x8DB3, 0,
     16, 0x2F9D, 0x8EAB, 0,
     16, 0x2F9E, 0x8ECA, 0,
     16, 0x2F9F, 0x8F9B, 0,
     16, 0x2FA0, 0x8FB0, 0,
     16, 0x2FA1, 0x8FB5, 0,
     16, 0x2FA2, 0x9091, 0,
     16, 0x2FA3, 0x9149, 0,
     16, 0x2FA4, 0x91C6, 0,
     16, 0x2FA5, 0x91CC, 0,
     16, 0x2FA6, 0x91D1, 0,
     16, 0x2FA7, 0x9577, 0,
     16, 0x2FA8, 0x9580, 0,
     16, 0x2FA9, 0x961C, 0,
     16, 0x2FAA, 0x96B6, 0,
     16, 0x2FAB, 0x96B9, 0,
     16, 0x2FAC, 0x96E8, 0,
     16, 0x2FAD, 0x9751, 0,
     16, 0x2FAE, 0x975E, 0,
     16, 0x2FAF, 0x9762, 0,
     16, 0x2FB0, 0x9769, 0,
     16, 0x2FB1, 0x97CB, 0,
     16, 0x2FB2, 0x97ED, 0,
     16, 0x2FB3, 0x97F3, 0,
     16, 0x2FB4, 0x9801, 0,
     16, 0x2FB5, 0x98A8, 0,
     16, 0x2FB6, 0x98DB, 0,
     16, 0x2FB7, 0x98DF, 0,
     16, 0x2FB8, 0x9996, 0,
     16, 0x2FB9, 0x9999, 0,
     16, 0x2FBA, 0x99AC, 0,
     16, 0x2FBB, 0x9AA8, 0,
     16, 0x2FBC, 0x9AD8, 0,
     16, 0x2FBD, 0x9ADF, 0,
     16, 0x2FBE, 0x9B25, 0,
     16, 0x2FBF, 0x9B2F, 0,
     16, 0x2FC0, 0x9B32, 0,
     16, 0x2FC1, 0x9B3C, 0,
     16, 0x2FC2, 0x9B5A, 0,
     16, 0x2FC3, 0x9CE5, 0,
     16, 0x2FC4, 0x9E75, 0,
     16, 0x2FC5, 0x9E7F, 0,
     16, 0x2FC6, 0x9EA5, 0,
     16, 0x2FC7, 0x9EBB, 0,
     16, 0x2FC8, 0x9EC3, 0,
     16, 0x2FC9, 0x9ECD, 0,
     16, 0x2FCA, 0x9ED1, 0,
     16, 0x2FCB, 0x9EF9, 0,
     16, 0x2FCC, 0x9EFD, 0,
     16, 0x2FCD, 0x9F0E, 0,
     16, 0x2FCE, 0x9F13, 0,
     16, 0x2FCF, 0x9F20, 0,
     16, 0x2FD0, 0x9F3B, 0,
     16, 0x2FD1, 0x9F4A, 0,
     16, 0x2FD2, 0x9F52, 0,
     16, 0x2FD3, 0x9F8D, 0,
     16, 0x2FD4, 0x9F9C, 0,
     16, 0x2FD5, 0x9FA0, 0,
     12, 0x3000, 0x0020, 0,
     16, 0x3036, 0x3012, 0,
     16, 0x3038, 0x5341, 0,
     16, 0x3039, 0x5344, 0,
     16, 0x303A, 0x5345, 0,
     1, 0x304C, 0x304B, 0x3099, 0,
     1, 0x304E, 0x304D, 0x3099, 0,
     1, 0x3050, 0x304F, 0x3099, 0,
     1, 0x3052, 0x3051, 0x3099, 0,
     1, 0x3054, 0x3053, 0x3099, 0,
     1, 0x3056, 0x3055, 0x3099, 0,
     1, 0x3058, 0x3057, 0x3099, 0,
     1, 0x305A, 0x3059, 0x3099, 0,
     1, 0x305C, 0x305B, 0x3099, 0,
     1, 0x305E, 0x305D, 0x3099, 0,
     1, 0x3060, 0x305F, 0x3099, 0,
     1, 0x3062, 0x3061, 0x3099, 0,
     1, 0x3065, 0x3064, 0x3099, 0,
     1, 0x3067, 0x3066, 0x3099, 0,
     1, 0x3069, 0x3068, 0x3099, 0,
     1, 0x3070, 0x306F, 0x3099, 0,
     1, 0x3071, 0x306F, 0x309A, 0,
     1, 0x3073, 0x3072, 0x3099, 0,
     1, 0x3074, 0x3072, 0x309A, 0,
     1, 0x3076, 0x3075, 0x3099, 0,
     1, 0x3077, 0x3075, 0x309A, 0,
     1, 0x3079, 0x3078, 0x3099, 0,
     1, 0x307A, 0x3078, 0x309A, 0,
     1, 0x307C, 0x307B, 0x3099, 0,
     1, 0x307D, 0x307B, 0x309A, 0,
     1, 0x3094, 0x3046, 0x3099, 0,
     16, 0x309B, 0x0020, 0x3099, 0,
     16, 0x309C, 0x0020, 0x309A, 0,
     1, 0x309E, 0x309D, 0x3099, 0,
     11, 0x309F, 0x3088, 0x308A, 0,
     1, 0x30AC, 0x30AB, 0x3099, 0,
     1, 0x30AE, 0x30AD, 0x3099, 0,
     1, 0x30B0, 0x30AF, 0x3099, 0,
     1, 0x30B2, 0x30B1, 0x3099, 0,
     1, 0x30B4, 0x30B3, 0x3099, 0,
     1, 0x30B6, 0x30B5, 0x3099, 0,
     1, 0x30B8, 0x30B7, 0x3099, 0,
     1, 0x30BA, 0x30B9, 0x3099, 0,
     1, 0x30BC, 0x30BB, 0x3099, 0,
     1, 0x30BE, 0x30BD, 0x3099, 0,
     1, 0x30C0, 0x30BF, 0x3099, 0,
     1, 0x30C2, 0x30C1, 0x3099, 0,
     1, 0x30C5, 0x30C4, 0x3099, 0,
     1, 0x30C7, 0x30C6, 0x3099, 0,
     1, 0x30C9, 0x30C8, 0x3099, 0,
     1, 0x30D0, 0x30CF, 0x3099, 0,
     1, 0x30D1, 0x30CF, 0x309A, 0,
     1, 0x30D3, 0x30D2, 0x3099, 0,
     1, 0x30D4, 0x30D2, 0x309A, 0,
     1, 0x30D6, 0x30D5, 0x3099, 0,
     1, 0x30D7, 0x30D5, 0x309A, 0,
     1, 0x30D9, 0x30D8, 0x3099, 0,
     1, 0x30DA, 0x30D8, 0x309A, 0,
     1, 0x30DC, 0x30DB, 0x3099, 0,
     1, 0x30DD, 0x30DB, 0x309A, 0,
     1, 0x30F4, 0x30A6, 0x3099, 0,
     1, 0x30F7, 0x30EF, 0x3099, 0,
     1, 0x30F8, 0x30F0, 0x3099, 0,
     1, 0x30F9, 0x30F1, 0x3099, 0,
     1, 0x30FA, 0x30F2, 0x3099, 0,
     1, 0x30FE, 0x30FD, 0x3099, 0,
     11, 0x30FF, 0x30B3, 0x30C8, 0,
     16, 0x3131, 0x1100, 0,
     16, 0x3132, 0x1101, 0,
     16, 0x3133, 0x11AA, 0,
     16, 0x3134, 0x1102, 0,
     16, 0x3135, 0x11AC, 0,
     16, 0x3136, 0x11AD, 0,
     16, 0x3137, 0x1103, 0,
     16, 0x3138, 0x1104, 0,
     16, 0x3139, 0x1105, 0,
     16, 0x313A, 0x11B0, 0,
     16, 0x313B, 0x11B1, 0,
     16, 0x313C, 0x11B2, 0,
     16, 0x313D, 0x11B3, 0,
     16, 0x313E, 0x11B4, 0,
     16, 0x313F, 0x11B5, 0,
     16, 0x3140, 0x111A, 0,
     16, 0x3141, 0x1106, 0,
     16, 0x3142, 0x1107, 0,
     16, 0x3143, 0x1108, 0,
     16, 0x3144, 0x1121, 0,
     16, 0x3145, 0x1109, 0,
     16, 0x3146, 0x110A, 0,
     16, 0x3147, 0x110B, 0,
     16, 0x3148, 0x110C, 0,
     16, 0x3149, 0x110D, 0,
     16, 0x314A, 0x110E, 0,
     16, 0x314B, 0x110F, 0,
     16, 0x314C, 0x1110, 0,
     16, 0x314D, 0x1111, 0,
     16, 0x314E, 0x1112, 0,
     16, 0x314F, 0x1161, 0,
     16, 0x3150, 0x1162, 0,
     16, 0x3151, 0x1163, 0,
     16, 0x3152, 0x1164, 0,
     16, 0x3153, 0x1165, 0,
     16, 0x3154, 0x1166, 0,
     16, 0x3155, 0x1167, 0,
     16, 0x3156, 0x1168, 0,
     16, 0x3157, 0x1169, 0,
     16, 0x3158, 0x116A, 0,
     16, 0x3159, 0x116B, 0,
     16, 0x315A, 0x116C, 0,
     16, 0x315B, 0x116D, 0,
     16, 0x315C, 0x116E, 0,
     16, 0x315D, 0x116F, 0,
     16, 0x315E, 0x1170, 0,
     16, 0x315F, 0x1171, 0,
     16, 0x3160, 0x1172, 0,
     16, 0x3161, 0x1173, 0,
     16, 0x3162, 0x1174, 0,
     16, 0x3163, 0x1175, 0,
     16, 0x3164, 0x1160, 0,
     16, 0x3165, 0x1114, 0,
     16, 0x3166, 0x1115, 0,
     16, 0x3167, 0x11C7, 0,
     16, 0x3168, 0x11C8, 0,
     16, 0x3169, 0x11CC, 0,
     16, 0x316A, 0x11CE, 0,
     16, 0x316B, 0x11D3, 0,
     16, 0x316C, 0x11D7, 0,
     16, 0x316D, 0x11D9, 0,
     16, 0x316E, 0x111C, 0,
     16, 0x316F, 0x11DD, 0,
     16, 0x3170, 0x11DF, 0,
     16, 0x3171, 0x111D, 0,
     16, 0x3172, 0x111E, 0,
     16, 0x3173, 0x1120, 0,
     16, 0x3174, 0x1122, 0,
     16, 0x3175, 0x1123, 0,
     16, 0x3176, 0x1127, 0,
     16, 0x3177, 0x1129, 0,
     16, 0x3178, 0x112B, 0,
     16, 0x3179, 0x112C, 0,
     16, 0x317A, 0x112D, 0,
     16, 0x317B, 0x112E, 0,
     16, 0x317C, 0x112F, 0,
     16, 0x317D, 0x1132, 0,
     16, 0x317E, 0x1136, 0,
     16, 0x317F, 0x1140, 0,
     16, 0x3180, 0x1147, 0,
     16, 0x3181, 0x114C, 0,
     16, 0x3182, 0x11F1, 0,
     16, 0x3183, 0x11F2, 0,
     16, 0x3184, 0x1157, 0,
     16, 0x3185, 0x1158, 0,
     16, 0x3186, 0x1159, 0,
     16, 0x3187, 0x1184, 0,
     16, 0x3188, 0x1185, 0,
     16, 0x3189, 0x1188, 0,
     16, 0x318A, 0x1191, 0,
     16, 0x318B, 0x1192, 0,
     16, 0x318C, 0x1194, 0,
     16, 0x318D, 0x119E, 0,
     16, 0x318E, 0x11A1, 0,
     9, 0x3192, 0x4E00, 0,
     9, 0x3193, 0x4E8C, 0,
     9, 0x3194, 0x4E09, 0,
     9, 0x3195, 0x56DB, 0,
     9, 0x3196, 0x4E0A, 0,
     9, 0x3197, 0x4E2D, 0,
     9, 0x3198, 0x4E0B, 0,
     9, 0x3199, 0x7532, 0,
     9, 0x319A, 0x4E59, 0,
     9, 0x319B, 0x4E19, 0,
     9, 0x319C, 0x4E01, 0,
     9, 0x319D, 0x5929, 0,
     9, 0x319E, 0x5730, 0,
     9, 0x319F, 0x4EBA, 0,
     16, 0x3200, 0x0028, 0x1100, 0x0029, 0,
     16, 0x3201, 0x0028, 0x1102, 0x0029, 0,
     16, 0x3202, 0x0028, 0x1103, 0x0029, 0,
     16, 0x3203, 0x0028, 0x1105, 0x0029, 0,
     16, 0x3204, 0x0028, 0x1106, 0x0029, 0,
     16, 0x3205, 0x0028, 0x1107, 0x0029, 0,
     16, 0x3206, 0x0028, 0x1109, 0x0029, 0,
     16, 0x3207, 0x0028, 0x110B, 0x0029, 0,
     16, 0x3208, 0x0028, 0x110C, 0x0029, 0,
     16, 0x3209, 0x0028, 0x110E, 0x0029, 0,
     16, 0x320A, 0x0028, 0x110F, 0x0029, 0,
     16, 0x320B, 0x0028, 0x1110, 0x0029, 0,
     16, 0x320C, 0x0028, 0x1111, 0x0029, 0,
     16, 0x320D, 0x0028, 0x1112, 0x0029, 0,
     16, 0x320E, 0x0028, 0x1100, 0x1161, 0x0029, 0,
     16, 0x320F, 0x0028, 0x1102, 0x1161, 0x0029, 0,
     16, 0x3210, 0x0028, 0x1103, 0x1161, 0x0029, 0,
     16, 0x3211, 0x0028, 0x1105, 0x1161, 0x0029, 0,
     16, 0x3212, 0x0028, 0x1106, 0x1161, 0x0029, 0,
     16, 0x3213, 0x0028, 0x1107, 0x1161, 0x0029, 0,
     16, 0x3214, 0x0028, 0x1109, 0x1161, 0x0029, 0,
     16, 0x3215, 0x0028, 0x110B, 0x1161, 0x0029, 0,
     16, 0x3216, 0x0028, 0x110C, 0x1161, 0x0029, 0,
     16, 0x3217, 0x0028, 0x110E, 0x1161, 0x0029, 0,
     16, 0x3218, 0x0028, 0x110F, 0x1161, 0x0029, 0,
     16, 0x3219, 0x0028, 0x1110, 0x1161, 0x0029, 0,
     16, 0x321A, 0x0028, 0x1111, 0x1161, 0x0029, 0,
     16, 0x321B, 0x0028, 0x1112, 0x1161, 0x0029, 0,
     16, 0x321C, 0x0028, 0x110C, 0x116E, 0x0029, 0,
     16, 0x3220, 0x0028, 0x4E00, 0x0029, 0,
     16, 0x3221, 0x0028, 0x4E8C, 0x0029, 0,
     16, 0x3222, 0x0028, 0x4E09, 0x0029, 0,
     16, 0x3223, 0x0028, 0x56DB, 0x0029, 0,
     16, 0x3224, 0x0028, 0x4E94, 0x0029, 0,
     16, 0x3225, 0x0028, 0x516D, 0x0029, 0,
     16, 0x3226, 0x0028, 0x4E03, 0x0029, 0,
     16, 0x3227, 0x0028, 0x516B, 0x0029, 0,
     16, 0x3228, 0x0028, 0x4E5D, 0x0029, 0,
     16, 0x3229, 0x0028, 0x5341, 0x0029, 0,
     16, 0x322A, 0x0028, 0x6708, 0x0029, 0,
     16, 0x322B, 0x0028, 0x706B, 0x0029, 0,
     16, 0x322C, 0x0028, 0x6C34, 0x0029, 0,
     16, 0x322D, 0x0028, 0x6728, 0x0029, 0,
     16, 0x322E, 0x0028, 0x91D1, 0x0029, 0,
     16, 0x322F, 0x0028, 0x571F, 0x0029, 0,
     16, 0x3230, 0x0028, 0x65E5, 0x0029, 0,
     16, 0x3231, 0x0028, 0x682A, 0x0029, 0,
     16, 0x3232, 0x0028, 0x6709, 0x0029, 0,
     16, 0x3233, 0x0028, 0x793E, 0x0029, 0,
     16, 0x3234, 0x0028, 0x540D, 0x0029, 0,
     16, 0x3235, 0x0028, 0x7279, 0x0029, 0,
     16, 0x3236, 0x0028, 0x8CA1, 0x0029, 0,
     16, 0x3237, 0x0028, 0x795D, 0x0029, 0,
     16, 0x3238, 0x0028, 0x52B4, 0x0029, 0,
     16, 0x3239, 0x0028, 0x4EE3, 0x0029, 0,
     16, 0x323A, 0x0028, 0x547C, 0x0029, 0,
     16, 0x323B, 0x0028, 0x5B66, 0x0029, 0,
     16, 0x323C, 0x0028, 0x76E3, 0x0029, 0,
     16, 0x323D, 0x0028, 0x4F01, 0x0029, 0,
     16, 0x323E, 0x0028, 0x8CC7, 0x0029, 0,
     16, 0x323F, 0x0028, 0x5354, 0x0029, 0,
     16, 0x3240, 0x0028, 0x796D, 0x0029, 0,
     16, 0x3241, 0x0028, 0x4F11, 0x0029, 0,
     16, 0x3242, 0x0028, 0x81EA, 0x0029, 0,
     16, 0x3243, 0x0028, 0x81F3, 0x0029, 0,
     8, 0x3251, 0x0032, 0x0031, 0,
     8, 0x3252, 0x0032, 0x0032, 0,
     8, 0x3253, 0x0032, 0x0033, 0,
     8, 0x3254, 0x0032, 0x0034, 0,
     8, 0x3255, 0x0032, 0x0035, 0,
     8, 0x3256, 0x0032, 0x0036, 0,
     8, 0x3257, 0x0032, 0x0037, 0,
     8, 0x3258, 0x0032, 0x0038, 0,
     8, 0x3259, 0x0032, 0x0039, 0,
     8, 0x325A, 0x0033, 0x0030, 0,
     8, 0x325B, 0x0033, 0x0031, 0,
     8, 0x325C, 0x0033, 0x0032, 0,
     8, 0x325D, 0x0033, 0x0033, 0,
     8, 0x325E, 0x0033, 0x0034, 0,
     8, 0x325F, 0x0033, 0x0035, 0,
     8, 0x3260, 0x1100, 0,
     8, 0x3261, 0x1102, 0,
     8, 0x3262, 0x1103, 0,
     8, 0x3263, 0x1105, 0,
     8, 0x3264, 0x1106, 0,
     8, 0x3265, 0x1107, 0,
     8, 0x3266, 0x1109, 0,
     8, 0x3267, 0x110B, 0,
     8, 0x3268, 0x110C, 0,
     8, 0x3269, 0x110E, 0,
     8, 0x326A, 0x110F, 0,
     8, 0x326B, 0x1110, 0,
     8, 0x326C, 0x1111, 0,
     8, 0x326D, 0x1112, 0,
     8, 0x326E, 0x1100, 0x1161, 0,
     8, 0x326F, 0x1102, 0x1161, 0,
     8, 0x3270, 0x1103, 0x1161, 0,
     8, 0x3271, 0x1105, 0x1161, 0,
     8, 0x3272, 0x1106, 0x1161, 0,
     8, 0x3273, 0x1107, 0x1161, 0,
     8, 0x3274, 0x1109, 0x1161, 0,
     8, 0x3275, 0x110B, 0x1161, 0,
     8, 0x3276, 0x110C, 0x1161, 0,
     8, 0x3277, 0x110E, 0x1161, 0,
     8, 0x3278, 0x110F, 0x1161, 0,
     8, 0x3279, 0x1110, 0x1161, 0,
     8, 0x327A, 0x1111, 0x1161, 0,
     8, 0x327B, 0x1112, 0x1161, 0,
     8, 0x3280, 0x4E00, 0,
     8, 0x3281, 0x4E8C, 0,
     8, 0x3282, 0x4E09, 0,
     8, 0x3283, 0x56DB, 0,
     8, 0x3284, 0x4E94, 0,
     8, 0x3285, 0x516D, 0,
     8, 0x3286, 0x4E03, 0,
     8, 0x3287, 0x516B, 0,
     8, 0x3288, 0x4E5D, 0,
     8, 0x3289, 0x5341, 0,
     8, 0x328A, 0x6708, 0,
     8, 0x328B, 0x706B, 0,
     8, 0x328C, 0x6C34, 0,
     8, 0x328D, 0x6728, 0,
     8, 0x328E, 0x91D1, 0,
     8, 0x328F, 0x571F, 0,
     8, 0x3290, 0x65E5, 0,
     8, 0x3291, 0x682A, 0,
     8, 0x3292, 0x6709, 0,
     8, 0x3293, 0x793E, 0,
     8, 0x3294, 0x540D, 0,
     8, 0x3295, 0x7279, 0,
     8, 0x3296, 0x8CA1, 0,
     8, 0x3297, 0x795D, 0,
     8, 0x3298, 0x52B4, 0,
     8, 0x3299, 0x79D8, 0,
     8, 0x329A, 0x7537, 0,
     8, 0x329B, 0x5973, 0,
     8, 0x329C, 0x9069, 0,
     8, 0x329D, 0x512A, 0,
     8, 0x329E, 0x5370, 0,
     8, 0x329F, 0x6CE8, 0,
     8, 0x32A0, 0x9805, 0,
     8, 0x32A1, 0x4F11, 0,
     8, 0x32A2, 0x5199, 0,
     8, 0x32A3, 0x6B63, 0,
     8, 0x32A4, 0x4E0A, 0,
     8, 0x32A5, 0x4E2D, 0,
     8, 0x32A6, 0x4E0B, 0,
     8, 0x32A7, 0x5DE6, 0,
     8, 0x32A8, 0x53F3, 0,
     8, 0x32A9, 0x533B, 0,
     8, 0x32AA, 0x5B97, 0,
     8, 0x32AB, 0x5B66, 0,
     8, 0x32AC, 0x76E3, 0,
     8, 0x32AD, 0x4F01, 0,
     8, 0x32AE, 0x8CC7, 0,
     8, 0x32AF, 0x5354, 0,
     8, 0x32B0, 0x591C, 0,
     8, 0x32B1, 0x0033, 0x0036, 0,
     8, 0x32B2, 0x0033, 0x0037, 0,
     8, 0x32B3, 0x0033, 0x0038, 0,
     8, 0x32B4, 0x0033, 0x0039, 0,
     8, 0x32B5, 0x0034, 0x0030, 0,
     8, 0x32B6, 0x0034, 0x0031, 0,
     8, 0x32B7, 0x0034, 0x0032, 0,
     8, 0x32B8, 0x0034, 0x0033, 0,
     8, 0x32B9, 0x0034, 0x0034, 0,
     8, 0x32BA, 0x0034, 0x0035, 0,
     8, 0x32BB, 0x0034, 0x0036, 0,
     8, 0x32BC, 0x0034, 0x0037, 0,
     8, 0x32BD, 0x0034, 0x0038, 0,
     8, 0x32BE, 0x0034, 0x0039, 0,
     8, 0x32BF, 0x0035, 0x0030, 0,
     16, 0x32C0, 0x0031, 0x6708, 0,
     16, 0x32C1, 0x0032, 0x6708, 0,
     16, 0x32C2, 0x0033, 0x6708, 0,
     16, 0x32C3, 0x0034, 0x6708, 0,
     16, 0x32C4, 0x0035, 0x6708, 0,
     16, 0x32C5, 0x0036, 0x6708, 0,
     16, 0x32C6, 0x0037, 0x6708, 0,
     16, 0x32C7, 0x0038, 0x6708, 0,
     16, 0x32C8, 0x0039, 0x6708, 0,
     16, 0x32C9, 0x0031, 0x0030, 0x6708, 0,
     16, 0x32CA, 0x0031, 0x0031, 0x6708, 0,
     16, 0x32CB, 0x0031, 0x0032, 0x6708, 0,
     8, 0x32D0, 0x30A2, 0,
     8, 0x32D1, 0x30A4, 0,
     8, 0x32D2, 0x30A6, 0,
     8, 0x32D3, 0x30A8, 0,
     8, 0x32D4, 0x30AA, 0,
     8, 0x32D5, 0x30AB, 0,
     8, 0x32D6, 0x30AD, 0,
     8, 0x32D7, 0x30AF, 0,
     8, 0x32D8, 0x30B1, 0,
     8, 0x32D9, 0x30B3, 0,
     8, 0x32DA, 0x30B5, 0,
     8, 0x32DB, 0x30B7, 0,
     8, 0x32DC, 0x30B9, 0,
     8, 0x32DD, 0x30BB, 0,
     8, 0x32DE, 0x30BD, 0,
     8, 0x32DF, 0x30BF, 0,
     8, 0x32E0, 0x30C1, 0,
     8, 0x32E1, 0x30C4, 0,
     8, 0x32E2, 0x30C6, 0,
     8, 0x32E3, 0x30C8, 0,
     8, 0x32E4, 0x30CA, 0,
     8, 0x32E5, 0x30CB, 0,
     8, 0x32E6, 0x30CC, 0,
     8, 0x32E7, 0x30CD, 0,
     8, 0x32E8, 0x30CE, 0,
     8, 0x32E9, 0x30CF, 0,
     8, 0x32EA, 0x30D2, 0,
     8, 0x32EB, 0x30D5, 0,
     8, 0x32EC, 0x30D8, 0,
     8, 0x32ED, 0x30DB, 0,
     8, 0x32EE, 0x30DE, 0,
     8, 0x32EF, 0x30DF, 0,
     8, 0x32F0, 0x30E0, 0,
     8, 0x32F1, 0x30E1, 0,
     8, 0x32F2, 0x30E2, 0,
     8, 0x32F3, 0x30E4, 0,
     8, 0x32F4, 0x30E6, 0,
     8, 0x32F5, 0x30E8, 0,
     8, 0x32F6, 0x30E9, 0,
     8, 0x32F7, 0x30EA, 0,
     8, 0x32F8, 0x30EB, 0,
     8, 0x32F9, 0x30EC, 0,
     8, 0x32FA, 0x30ED, 0,
     8, 0x32FB, 0x30EF, 0,
     8, 0x32FC, 0x30F0, 0,
     8, 0x32FD, 0x30F1, 0,
     8, 0x32FE, 0x30F2, 0,
     15, 0x3300, 0x30A2, 0x30D1, 0x30FC, 0x30C8, 0,
     15, 0x3301, 0x30A2, 0x30EB, 0x30D5, 0x30A1, 0,
     15, 0x3302, 0x30A2, 0x30F3, 0x30DA, 0x30A2, 0,
     15, 0x3303, 0x30A2, 0x30FC, 0x30EB, 0,
     15, 0x3304, 0x30A4, 0x30CB, 0x30F3, 0x30B0, 0,
     15, 0x3305, 0x30A4, 0x30F3, 0x30C1, 0,
     15, 0x3306, 0x30A6, 0x30A9, 0x30F3, 0,
     15, 0x3307, 0x30A8, 0x30B9, 0x30AF, 0x30FC, 0x30C9, 0,
     15, 0x3308, 0x30A8, 0x30FC, 0x30AB, 0x30FC, 0,
     15, 0x3309, 0x30AA, 0x30F3, 0x30B9, 0,
     15, 0x330A, 0x30AA, 0x30FC, 0x30E0, 0,
     15, 0x330B, 0x30AB, 0x30A4, 0x30EA, 0,
     15, 0x330C, 0x30AB, 0x30E9, 0x30C3, 0x30C8, 0,
     15, 0x330D, 0x30AB, 0x30ED, 0x30EA, 0x30FC, 0,
     15, 0x330E, 0x30AC, 0x30ED, 0x30F3, 0,
     15, 0x330F, 0x30AC, 0x30F3, 0x30DE, 0,
     15, 0x3310, 0x30AE, 0x30AC, 0,
     15, 0x3311, 0x30AE, 0x30CB, 0x30FC, 0,
     15, 0x3312, 0x30AD, 0x30E5, 0x30EA, 0x30FC, 0,
     15, 0x3313, 0x30AE, 0x30EB, 0x30C0, 0x30FC, 0,
     15, 0x3314, 0x30AD, 0x30ED, 0,
     15, 0x3315, 0x30AD, 0x30ED, 0x30B0, 0x30E9, 0x30E0, 0,
     15, 0x3316, 0x30AD, 0x30ED, 0x30E1, 0x30FC, 0x30C8, 0x30EB, 0,
     15, 0x3317, 0x30AD, 0x30ED, 0x30EF, 0x30C3, 0x30C8, 0,
     15, 0x3318, 0x30B0, 0x30E9, 0x30E0, 0,
     15, 0x3319, 0x30B0, 0x30E9, 0x30E0, 0x30C8, 0x30F3, 0,
     15, 0x331A, 0x30AF, 0x30EB, 0x30BC, 0x30A4, 0x30ED, 0,
     15, 0x331B, 0x30AF, 0x30ED, 0x30FC, 0x30CD, 0,
     15, 0x331C, 0x30B1, 0x30FC, 0x30B9, 0,
     15, 0x331D, 0x30B3, 0x30EB, 0x30CA, 0,
     15, 0x331E, 0x30B3, 0x30FC, 0x30DD, 0,
     15, 0x331F, 0x30B5, 0x30A4, 0x30AF, 0x30EB, 0,
     15, 0x3320, 0x30B5, 0x30F3, 0x30C1, 0x30FC, 0x30E0, 0,
     15, 0x3321, 0x30B7, 0x30EA, 0x30F3, 0x30B0, 0,
     15, 0x3322, 0x30BB, 0x30F3, 0x30C1, 0,
     15, 0x3323, 0x30BB, 0x30F3, 0x30C8, 0,
     15, 0x3324, 0x30C0, 0x30FC, 0x30B9, 0,
     15, 0x3325, 0x30C7, 0x30B7, 0,
     15, 0x3326, 0x30C9, 0x30EB, 0,
     15, 0x3327, 0x30C8, 0x30F3, 0,
     15, 0x3328, 0x30CA, 0x30CE, 0,
     15, 0x3329, 0x30CE, 0x30C3, 0x30C8, 0,
     15, 0x332A, 0x30CF, 0x30A4, 0x30C4, 0,
     15, 0x332B, 0x30D1, 0x30FC, 0x30BB, 0x30F3, 0x30C8, 0,
     15, 0x332C, 0x30D1, 0x30FC, 0x30C4, 0,
     15, 0x332D, 0x30D0, 0x30FC, 0x30EC, 0x30EB, 0,
     15, 0x332E, 0x30D4, 0x30A2, 0x30B9, 0x30C8, 0x30EB, 0,
     15, 0x332F, 0x30D4, 0x30AF, 0x30EB, 0,
     15, 0x3330, 0x30D4, 0x30B3, 0,
     15, 0x3331, 0x30D3, 0x30EB, 0,
     15, 0x3332, 0x30D5, 0x30A1, 0x30E9, 0x30C3, 0x30C9, 0,
     15, 0x3333, 0x30D5, 0x30A3, 0x30FC, 0x30C8, 0,
     15, 0x3334, 0x30D6, 0x30C3, 0x30B7, 0x30A7, 0x30EB, 0,
     15, 0x3335, 0x30D5, 0x30E9, 0x30F3, 0,
     15, 0x3336, 0x30D8, 0x30AF, 0x30BF, 0x30FC, 0x30EB, 0,
     15, 0x3337, 0x30DA, 0x30BD, 0,
     15, 0x3338, 0x30DA, 0x30CB, 0x30D2, 0,
     15, 0x3339, 0x30D8, 0x30EB, 0x30C4, 0,
     15, 0x333A, 0x30DA, 0x30F3, 0x30B9, 0,
     15, 0x333B, 0x30DA, 0x30FC, 0x30B8, 0,
     15, 0x333C, 0x30D9, 0x30FC, 0x30BF, 0,
     15, 0x333D, 0x30DD, 0x30A4, 0x30F3, 0x30C8, 0,
     15, 0x333E, 0x30DC, 0x30EB, 0x30C8, 0,
     15, 0x333F, 0x30DB, 0x30F3, 0,
     15, 0x3340, 0x30DD, 0x30F3, 0x30C9, 0,
     15, 0x3341, 0x30DB, 0x30FC, 0x30EB, 0,
     15, 0x3342, 0x30DB, 0x30FC, 0x30F3, 0,
     15, 0x3343, 0x30DE, 0x30A4, 0x30AF, 0x30ED, 0,
     15, 0x3344, 0x30DE, 0x30A4, 0x30EB, 0,
     15, 0x3345, 0x30DE, 0x30C3, 0x30CF, 0,
     15, 0x3346, 0x30DE, 0x30EB, 0x30AF, 0,
     15, 0x3347, 0x30DE, 0x30F3, 0x30B7, 0x30E7, 0x30F3, 0,
     15, 0x3348, 0x30DF, 0x30AF, 0x30ED, 0x30F3, 0,
     15, 0x3349, 0x30DF, 0x30EA, 0,
     15, 0x334A, 0x30DF, 0x30EA, 0x30D0, 0x30FC, 0x30EB, 0,
     15, 0x334B, 0x30E1, 0x30AC, 0,
     15, 0x334C, 0x30E1, 0x30AC, 0x30C8, 0x30F3, 0,
     15, 0x334D, 0x30E1, 0x30FC, 0x30C8, 0x30EB, 0,
     15, 0x334E, 0x30E4, 0x30FC, 0x30C9, 0,
     15, 0x334F, 0x30E4, 0x30FC, 0x30EB, 0,
     15, 0x3350, 0x30E6, 0x30A2, 0x30F3, 0,
     15, 0x3351, 0x30EA, 0x30C3, 0x30C8, 0x30EB, 0,
     15, 0x3352, 0x30EA, 0x30E9, 0,
     15, 0x3353, 0x30EB, 0x30D4, 0x30FC, 0,
     15, 0x3354, 0x30EB, 0x30FC, 0x30D6, 0x30EB, 0,
     15, 0x3355, 0x30EC, 0x30E0, 0,
     15, 0x3356, 0x30EC, 0x30F3, 0x30C8, 0x30B2, 0x30F3, 0,
     15, 0x3357, 0x30EF, 0x30C3, 0x30C8, 0,
     16, 0x3358, 0x0030, 0x70B9, 0,
     16, 0x3359, 0x0031, 0x70B9, 0,
     16, 0x335A, 0x0032, 0x70B9, 0,
     16, 0x335B, 0x0033, 0x70B9, 0,
     16, 0x335C, 0x0034, 0x70B9, 0,
     16, 0x335D, 0x0035, 0x70B9, 0,
     16, 0x335E, 0x0036, 0x70B9, 0,
     16, 0x335F, 0x0037, 0x70B9, 0,
     16, 0x3360, 0x0038, 0x70B9, 0,
     16, 0x3361, 0x0039, 0x70B9, 0,
     16, 0x3362, 0x0031, 0x0030, 0x70B9, 0,
     16, 0x3363, 0x0031, 0x0031, 0x70B9, 0,
     16, 0x3364, 0x0031, 0x0032, 0x70B9, 0,
     16, 0x3365, 0x0031, 0x0033, 0x70B9, 0,
     16, 0x3366, 0x0031, 0x0034, 0x70B9, 0,
     16, 0x3367, 0x0031, 0x0035, 0x70B9, 0,
     16, 0x3368, 0x0031, 0x0036, 0x70B9, 0,
     16, 0x3369, 0x0031, 0x0037, 0x70B9, 0,
     16, 0x336A, 0x0031, 0x0038, 0x70B9, 0,
     16, 0x336B, 0x0031, 0x0039, 0x70B9, 0,
     16, 0x336C, 0x0032, 0x0030, 0x70B9, 0,
     16, 0x336D, 0x0032, 0x0031, 0x70B9, 0,
     16, 0x336E, 0x0032, 0x0032, 0x70B9, 0,
     16, 0x336F, 0x0032, 0x0033, 0x70B9, 0,
     16, 0x3370, 0x0032, 0x0034, 0x70B9, 0,
     15, 0x3371, 0x0068, 0x0050, 0x0061, 0,
     15, 0x3372, 0x0064, 0x0061, 0,
     15, 0x3373, 0x0041, 0x0055, 0,
     15, 0x3374, 0x0062, 0x0061, 0x0072, 0,
     15, 0x3375, 0x006F, 0x0056, 0,
     15, 0x3376, 0x0070, 0x0063, 0,
     15, 0x337B, 0x5E73, 0x6210, 0,
     15, 0x337C, 0x662D, 0x548C, 0,
     15, 0x337D, 0x5927, 0x6B63, 0,
     15, 0x337E, 0x660E, 0x6CBB, 0,
     15, 0x337F, 0x682A, 0x5F0F, 0x4F1A, 0x793E, 0,
     15, 0x3380, 0x0070, 0x0041, 0,
     15, 0x3381, 0x006E, 0x0041, 0,
     15, 0x3382, 0x03BC, 0x0041, 0,
     15, 0x3383, 0x006D, 0x0041, 0,
     15, 0x3384, 0x006B, 0x0041, 0,
     15, 0x3385, 0x004B, 0x0042, 0,
     15, 0x3386, 0x004D, 0x0042, 0,
     15, 0x3387, 0x0047, 0x0042, 0,
     15, 0x3388, 0x0063, 0x0061, 0x006C, 0,
     15, 0x3389, 0x006B, 0x0063, 0x0061, 0x006C, 0,
     15, 0x338A, 0x0070, 0x0046, 0,
     15, 0x338B, 0x006E, 0x0046, 0,
     15, 0x338C, 0x03BC, 0x0046, 0,
     15, 0x338D, 0x03BC, 0x0067, 0,
     15, 0x338E, 0x006D, 0x0067, 0,
     15, 0x338F, 0x006B, 0x0067, 0,
     15, 0x3390, 0x0048, 0x007A, 0,
     15, 0x3391, 0x006B, 0x0048, 0x007A, 0,
     15, 0x3392, 0x004D, 0x0048, 0x007A, 0,
     15, 0x3393, 0x0047, 0x0048, 0x007A, 0,
     15, 0x3394, 0x0054, 0x0048, 0x007A, 0,
     15, 0x3395, 0x03BC, 0x2113, 0,
     15, 0x3396, 0x006D, 0x2113, 0,
     15, 0x3397, 0x0064, 0x2113, 0,
     15, 0x3398, 0x006B, 0x2113, 0,
     15, 0x3399, 0x0066, 0x006D, 0,
     15, 0x339A, 0x006E, 0x006D, 0,
     15, 0x339B, 0x03BC, 0x006D, 0,
     15, 0x339C, 0x006D, 0x006D, 0,
     15, 0x339D, 0x0063, 0x006D, 0,
     15, 0x339E, 0x006B, 0x006D, 0,
     15, 0x339F, 0x006D, 0x006D, 0x00B2, 0,
     15, 0x33A0, 0x0063, 0x006D, 0x00B2, 0,
     15, 0x33A1, 0x006D, 0x00B2, 0,
     15, 0x33A2, 0x006B, 0x006D, 0x00B2, 0,
     15, 0x33A3, 0x006D, 0x006D, 0x00B3, 0,
     15, 0x33A4, 0x0063, 0x006D, 0x00B3, 0,
     15, 0x33A5, 0x006D, 0x00B3, 0,
     15, 0x33A6, 0x006B, 0x006D, 0x00B3, 0,
     15, 0x33A7, 0x006D, 0x2215, 0x0073, 0,
     15, 0x33A8, 0x006D, 0x2215, 0x0073, 0x00B2, 0,
     15, 0x33A9, 0x0050, 0x0061, 0,
     15, 0x33AA, 0x006B, 0x0050, 0x0061, 0,
     15, 0x33AB, 0x004D, 0x0050, 0x0061, 0,
     15, 0x33AC, 0x0047, 0x0050, 0x0061, 0,
     15, 0x33AD, 0x0072, 0x0061, 0x0064, 0,
     15, 0x33AE, 0x0072, 0x0061, 0x0064, 0x2215, 0x0073, 0,
     15, 0x33AF, 0x0072, 0x0061, 0x0064, 0x2215, 0x0073, 0x00B2, 0,
     15, 0x33B0, 0x0070, 0x0073, 0,
     15, 0x33B1, 0x006E, 0x0073, 0,
     15, 0x33B2, 0x03BC, 0x0073, 0,
     15, 0x33B3, 0x006D, 0x0073, 0,
     15, 0x33B4, 0x0070, 0x0056, 0,
     15, 0x33B5, 0x006E, 0x0056, 0,
     15, 0x33B6, 0x03BC, 0x0056, 0,
     15, 0x33B7, 0x006D, 0x0056, 0,
     15, 0x33B8, 0x006B, 0x0056, 0,
     15, 0x33B9, 0x004D, 0x0056, 0,
     15, 0x33BA, 0x0070, 0x0057, 0,
     15, 0x33BB, 0x006E, 0x0057, 0,
     15, 0x33BC, 0x03BC, 0x0057, 0,
     15, 0x33BD, 0x006D, 0x0057, 0,
     15, 0x33BE, 0x006B, 0x0057, 0,
     15, 0x33BF, 0x004D, 0x0057, 0,
     15, 0x33C0, 0x006B, 0x03A9, 0,
     15, 0x33C1, 0x004D, 0x03A9, 0,
     15, 0x33C2, 0x0061, 0x002E, 0x006D, 0x002E, 0,
     15, 0x33C3, 0x0042, 0x0071, 0,
     15, 0x33C4, 0x0063, 0x0063, 0,
     15, 0x33C5, 0x0063, 0x0064, 0,
     15, 0x33C6, 0x0043, 0x2215, 0x006B, 0x0067, 0,
     15, 0x33C7, 0x0043, 0x006F, 0x002E, 0,
     15, 0x33C8, 0x0064, 0x0042, 0,
     15, 0x33C9, 0x0047, 0x0079, 0,
     15, 0x33CA, 0x0068, 0x0061, 0,
     15, 0x33CB, 0x0048, 0x0050, 0,
     15, 0x33CC, 0x0069, 0x006E, 0,
     15, 0x33CD, 0x004B, 0x004B, 0,
     15, 0x33CE, 0x004B, 0x004D, 0,
     15, 0x33CF, 0x006B, 0x0074, 0,
     15, 0x33D0, 0x006C, 0x006D, 0,
     15, 0x33D1, 0x006C, 0x006E, 0,
     15, 0x33D2, 0x006C, 0x006F, 0x0067, 0,
     15, 0x33D3, 0x006C, 0x0078, 0,
     15, 0x33D4, 0x006D, 0x0062, 0,
     15, 0x33D5, 0x006D, 0x0069, 0x006C, 0,
     15, 0x33D6, 0x006D, 0x006F, 0x006C, 0,
     15, 0x33D7, 0x0050, 0x0048, 0,
     15, 0x33D8, 0x0070, 0x002E, 0x006D, 0x002E, 0,
     15, 0x33D9, 0x0050, 0x0050, 0x004D, 0,
     15, 0x33DA, 0x0050, 0x0052, 0,
     15, 0x33DB, 0x0073, 0x0072, 0,
     15, 0x33DC, 0x0053, 0x0076, 0,
     15, 0x33DD, 0x0057, 0x0062, 0,
     16, 0x33E0, 0x0031, 0x65E5, 0,
     16, 0x33E1, 0x0032, 0x65E5, 0,
     16, 0x33E2, 0x0033, 0x65E5, 0,
     16, 0x33E3, 0x0034, 0x65E5, 0,
     16, 0x33E4, 0x0035, 0x65E5, 0,
     16, 0x33E5, 0x0036, 0x65E5, 0,
     16, 0x33E6, 0x0037, 0x65E5, 0,
     16, 0x33E7, 0x0038, 0x65E5, 0,
     16, 0x33E8, 0x0039, 0x65E5, 0,
     16, 0x33E9, 0x0031, 0x0030, 0x65E5, 0,
     16, 0x33EA, 0x0031, 0x0031, 0x65E5, 0,
     16, 0x33EB, 0x0031, 0x0032, 0x65E5, 0,
     16, 0x33EC, 0x0031, 0x0033, 0x65E5, 0,
     16, 0x33ED, 0x0031, 0x0034, 0x65E5, 0,
     16, 0x33EE, 0x0031, 0x0035, 0x65E5, 0,
     16, 0x33EF, 0x0031, 0x0036, 0x65E5, 0,
     16, 0x33F0, 0x0031, 0x0037, 0x65E5, 0,
     16, 0x33F1, 0x0031, 0x0038, 0x65E5, 0,
     16, 0x33F2, 0x0031, 0x0039, 0x65E5, 0,
     16, 0x33F3, 0x0032, 0x0030, 0x65E5, 0,
     16, 0x33F4, 0x0032, 0x0031, 0x65E5, 0,
     16, 0x33F5, 0x0032, 0x0032, 0x65E5, 0,
     16, 0x33F6, 0x0032, 0x0033, 0x65E5, 0,
     16, 0x33F7, 0x0032, 0x0034, 0x65E5, 0,
     16, 0x33F8, 0x0032, 0x0035, 0x65E5, 0,
     16, 0x33F9, 0x0032, 0x0036, 0x65E5, 0,
     16, 0x33FA, 0x0032, 0x0037, 0x65E5, 0,
     16, 0x33FB, 0x0032, 0x0038, 0x65E5, 0,
     16, 0x33FC, 0x0032, 0x0039, 0x65E5, 0,
     16, 0x33FD, 0x0033, 0x0030, 0x65E5, 0,
     16, 0x33FE, 0x0033, 0x0031, 0x65E5, 0,
     1, 0xF900, 0x8C48, 0,
     1, 0xF901, 0x66F4, 0,
     1, 0xF902, 0x8ECA, 0,
     1, 0xF903, 0x8CC8, 0,
     1, 0xF904, 0x6ED1, 0,
     1, 0xF905, 0x4E32, 0,
     1, 0xF906, 0x53E5, 0,
     1, 0xF907, 0x9F9C, 0,
     1, 0xF908, 0x9F9C, 0,
     1, 0xF909, 0x5951, 0,
     1, 0xF90A, 0x91D1, 0,
     1, 0xF90B, 0x5587, 0,
     1, 0xF90C, 0x5948, 0,
     1, 0xF90D, 0x61F6, 0,
     1, 0xF90E, 0x7669, 0,
     1, 0xF90F, 0x7F85, 0,
     1, 0xF910, 0x863F, 0,
     1, 0xF911, 0x87BA, 0,
     1, 0xF912, 0x88F8, 0,
     1, 0xF913, 0x908F, 0,
     1, 0xF914, 0x6A02, 0,
     1, 0xF915, 0x6D1B, 0,
     1, 0xF916, 0x70D9, 0,
     1, 0xF917, 0x73DE, 0,
     1, 0xF918, 0x843D, 0,
     1, 0xF919, 0x916A, 0,
     1, 0xF91A, 0x99F1, 0,
     1, 0xF91B, 0x4E82, 0,
     1, 0xF91C, 0x5375, 0,
     1, 0xF91D, 0x6B04, 0,
     1, 0xF91E, 0x721B, 0,
     1, 0xF91F, 0x862D, 0,
     1, 0xF920, 0x9E1E, 0,
     1, 0xF921, 0x5D50, 0,
     1, 0xF922, 0x6FEB, 0,
     1, 0xF923, 0x85CD, 0,
     1, 0xF924, 0x8964, 0,
     1, 0xF925, 0x62C9, 0,
     1, 0xF926, 0x81D8, 0,
     1, 0xF927, 0x881F, 0,
     1, 0xF928, 0x5ECA, 0,
     1, 0xF929, 0x6717, 0,
     1, 0xF92A, 0x6D6A, 0,
     1, 0xF92B, 0x72FC, 0,
     1, 0xF92C, 0x90CE, 0,
     1, 0xF92D, 0x4F86, 0,
     1, 0xF92E, 0x51B7, 0,
     1, 0xF92F, 0x52DE, 0,
     1, 0xF930, 0x64C4, 0,
     1, 0xF931, 0x6AD3, 0,
     1, 0xF932, 0x7210, 0,
     1, 0xF933, 0x76E7, 0,
     1, 0xF934, 0x8001, 0,
     1, 0xF935, 0x8606, 0,
     1, 0xF936, 0x865C, 0,
     1, 0xF937, 0x8DEF, 0,
     1, 0xF938, 0x9732, 0,
     1, 0xF939, 0x9B6F, 0,
     1, 0xF93A, 0x9DFA, 0,
     1, 0xF93B, 0x788C, 0,
     1, 0xF93C, 0x797F, 0,
     1, 0xF93D, 0x7DA0, 0,
     1, 0xF93E, 0x83C9, 0,
     1, 0xF93F, 0x9304, 0,
     1, 0xF940, 0x9E7F, 0,
     1, 0xF941, 0x8AD6, 0,
     1, 0xF942, 0x58DF, 0,
     1, 0xF943, 0x5F04, 0,
     1, 0xF944, 0x7C60, 0,
     1, 0xF945, 0x807E, 0,
     1, 0xF946, 0x7262, 0,
     1, 0xF947, 0x78CA, 0,
     1, 0xF948, 0x8CC2, 0,
     1, 0xF949, 0x96F7, 0,
     1, 0xF94A, 0x58D8, 0,
     1, 0xF94B, 0x5C62, 0,
     1, 0xF94C, 0x6A13, 0,
     1, 0xF94D, 0x6DDA, 0,
     1, 0xF94E, 0x6F0F, 0,
     1, 0xF94F, 0x7D2F, 0,
     1, 0xF950, 0x7E37, 0,
     1, 0xF951, 0x964B, 0,
     1, 0xF952, 0x52D2, 0,
     1, 0xF953, 0x808B, 0,
     1, 0xF954, 0x51DC, 0,
     1, 0xF955, 0x51CC, 0,
     1, 0xF956, 0x7A1C, 0,
     1, 0xF957, 0x7DBE, 0,
     1, 0xF958, 0x83F1, 0,
     1, 0xF959, 0x9675, 0,
     1, 0xF95A, 0x8B80, 0,
     1, 0xF95B, 0x62CF, 0,
     1, 0xF95C, 0x6A02, 0,
     1, 0xF95D, 0x8AFE, 0,
     1, 0xF95E, 0x4E39, 0,
     1, 0xF95F, 0x5BE7, 0,
     1, 0xF960, 0x6012, 0,
     1, 0xF961, 0x7387, 0,
     1, 0xF962, 0x7570, 0,
     1, 0xF963, 0x5317, 0,
     1, 0xF964, 0x78FB, 0,
     1, 0xF965, 0x4FBF, 0,
     1, 0xF966, 0x5FA9, 0,
     1, 0xF967, 0x4E0D, 0,
     1, 0xF968, 0x6CCC, 0,
     1, 0xF969, 0x6578, 0,
     1, 0xF96A, 0x7D22, 0,
     1, 0xF96B, 0x53C3, 0,
     1, 0xF96C, 0x585E, 0,
     1, 0xF96D, 0x7701, 0,
     1, 0xF96E, 0x8449, 0,
     1, 0xF96F, 0x8AAA, 0,
     1, 0xF970, 0x6BBA, 0,
     1, 0xF971, 0x8FB0, 0,
     1, 0xF972, 0x6C88, 0,
     1, 0xF973, 0x62FE, 0,
     1, 0xF974, 0x82E5, 0,
     1, 0xF975, 0x63A0, 0,
     1, 0xF976, 0x7565, 0,
     1, 0xF977, 0x4EAE, 0,
     1, 0xF978, 0x5169, 0,
     1, 0xF979, 0x51C9, 0,
     1, 0xF97A, 0x6881, 0,
     1, 0xF97B, 0x7CE7, 0,
     1, 0xF97C, 0x826F, 0,
     1, 0xF97D, 0x8AD2, 0,
     1, 0xF97E, 0x91CF, 0,
     1, 0xF97F, 0x52F5, 0,
     1, 0xF980, 0x5442, 0,
     1, 0xF981, 0x5973, 0,
     1, 0xF982, 0x5EEC, 0,
     1, 0xF983, 0x65C5, 0,
     1, 0xF984, 0x6FFE, 0,
     1, 0xF985, 0x792A, 0,
     1, 0xF986, 0x95AD, 0,
     1, 0xF987, 0x9A6A, 0,
     1, 0xF988, 0x9E97, 0,
     1, 0xF989, 0x9ECE, 0,
     1, 0xF98A, 0x529B, 0,
     1, 0xF98B, 0x66C6, 0,
     1, 0xF98C, 0x6B77, 0,
     1, 0xF98D, 0x8F62, 0,
     1, 0xF98E, 0x5E74, 0,
     1, 0xF98F, 0x6190, 0,
     1, 0xF990, 0x6200, 0,
     1, 0xF991, 0x649A, 0,
     1, 0xF992, 0x6F23, 0,
     1, 0xF993, 0x7149, 0,
     1, 0xF994, 0x7489, 0,
     1, 0xF995, 0x79CA, 0,
     1, 0xF996, 0x7DF4, 0,
     1, 0xF997, 0x806F, 0,
     1, 0xF998, 0x8F26, 0,
     1, 0xF999, 0x84EE, 0,
     1, 0xF99A, 0x9023, 0,
     1, 0xF99B, 0x934A, 0,
     1, 0xF99C, 0x5217, 0,
     1, 0xF99D, 0x52A3, 0,
     1, 0xF99E, 0x54BD, 0,
     1, 0xF99F, 0x70C8, 0,
     1, 0xF9A0, 0x88C2, 0,
     1, 0xF9A1, 0x8AAA, 0,
     1, 0xF9A2, 0x5EC9, 0,
     1, 0xF9A3, 0x5FF5, 0,
     1, 0xF9A4, 0x637B, 0,
     1, 0xF9A5, 0x6BAE, 0,
     1, 0xF9A6, 0x7C3E, 0,
     1, 0xF9A7, 0x7375, 0,
     1, 0xF9A8, 0x4EE4, 0,
     1, 0xF9A9, 0x56F9, 0,
     1, 0xF9AA, 0x5BE7, 0,
     1, 0xF9AB, 0x5DBA, 0,
     1, 0xF9AC, 0x601C, 0,
     1, 0xF9AD, 0x73B2, 0,
     1, 0xF9AE, 0x7469, 0,
     1, 0xF9AF, 0x7F9A, 0,
     1, 0xF9B0, 0x8046, 0,
     1, 0xF9B1, 0x9234, 0,
     1, 0xF9B2, 0x96F6, 0,
     1, 0xF9B3, 0x9748, 0,
     1, 0xF9B4, 0x9818, 0,
     1, 0xF9B5, 0x4F8B, 0,
     1, 0xF9B6, 0x79AE, 0,
     1, 0xF9B7, 0x91B4, 0,
     1, 0xF9B8, 0x96B8, 0,
     1, 0xF9B9, 0x60E1, 0,
     1, 0xF9BA, 0x4E86, 0,
     1, 0xF9BB, 0x50DA, 0,
     1, 0xF9BC, 0x5BEE, 0,
     1, 0xF9BD, 0x5C3F, 0,
     1, 0xF9BE, 0x6599, 0,
     1, 0xF9BF, 0x6A02, 0,
     1, 0xF9C0, 0x71CE, 0,
     1, 0xF9C1, 0x7642, 0,
     1, 0xF9C2, 0x84FC, 0,
     1, 0xF9C3, 0x907C, 0,
     1, 0xF9C4, 0x9F8D, 0,
     1, 0xF9C5, 0x6688, 0,
     1, 0xF9C6, 0x962E, 0,
     1, 0xF9C7, 0x5289, 0,
     1, 0xF9C8, 0x677B, 0,
     1, 0xF9C9, 0x67F3, 0,
     1, 0xF9CA, 0x6D41, 0,
     1, 0xF9CB, 0x6E9C, 0,
     1, 0xF9CC, 0x7409, 0,
     1, 0xF9CD, 0x7559, 0,
     1, 0xF9CE, 0x786B, 0,
     1, 0xF9CF, 0x7D10, 0,
     1, 0xF9D0, 0x985E, 0,
     1, 0xF9D1, 0x516D, 0,
     1, 0xF9D2, 0x622E, 0,
     1, 0xF9D3, 0x9678, 0,
     1, 0xF9D4, 0x502B, 0,
     1, 0xF9D5, 0x5D19, 0,
     1, 0xF9D6, 0x6DEA, 0,
     1, 0xF9D7, 0x8F2A, 0,
     1, 0xF9D8, 0x5F8B, 0,
     1, 0xF9D9, 0x6144, 0,
     1, 0xF9DA, 0x6817, 0,
     1, 0xF9DB, 0x7387, 0,
     1, 0xF9DC, 0x9686, 0,
     1, 0xF9DD, 0x5229, 0,
     1, 0xF9DE, 0x540F, 0,
     1, 0xF9DF, 0x5C65, 0,
     1, 0xF9E0, 0x6613, 0,
     1, 0xF9E1, 0x674E, 0,
     1, 0xF9E2, 0x68A8, 0,
     1, 0xF9E3, 0x6CE5, 0,
     1, 0xF9E4, 0x7406, 0,
     1, 0xF9E5, 0x75E2, 0,
     1, 0xF9E6, 0x7F79, 0,
     1, 0xF9E7, 0x88CF, 0,
     1, 0xF9E8, 0x88E1, 0,
     1, 0xF9E9, 0x91CC, 0,
     1, 0xF9EA, 0x96E2, 0,
     1, 0xF9EB, 0x533F, 0,
     1, 0xF9EC, 0x6EBA, 0,
     1, 0xF9ED, 0x541D, 0,
     1, 0xF9EE, 0x71D0, 0,
     1, 0xF9EF, 0x7498, 0,
     1, 0xF9F0, 0x85FA, 0,
     1, 0xF9F1, 0x96A3, 0,
     1, 0xF9F2, 0x9C57, 0,
     1, 0xF9F3, 0x9E9F, 0,
     1, 0xF9F4, 0x6797, 0,
     1, 0xF9F5, 0x6DCB, 0,
     1, 0xF9F6, 0x81E8, 0,
     1, 0xF9F7, 0x7ACB, 0,
     1, 0xF9F8, 0x7B20, 0,
     1, 0xF9F9, 0x7C92, 0,
     1, 0xF9FA, 0x72C0, 0,
     1, 0xF9FB, 0x7099, 0,
     1, 0xF9FC, 0x8B58, 0,
     1, 0xF9FD, 0x4EC0, 0,
     1, 0xF9FE, 0x8336, 0,
     1, 0xF9FF, 0x523A, 0,
     1, 0xFA00, 0x5207, 0,
     1, 0xFA01, 0x5EA6, 0,
     1, 0xFA02, 0x62D3, 0,
     1, 0xFA03, 0x7CD6, 0,
     1, 0xFA04, 0x5B85, 0,
     1, 0xFA05, 0x6D1E, 0,
     1, 0xFA06, 0x66B4, 0,
     1, 0xFA07, 0x8F3B, 0,
     1, 0xFA08, 0x884C, 0,
     1, 0xFA09, 0x964D, 0,
     1, 0xFA0A, 0x898B, 0,
     1, 0xFA0B, 0x5ED3, 0,
     1, 0xFA0C, 0x5140, 0,
     1, 0xFA0D, 0x55C0, 0,
     1, 0xFA10, 0x585A, 0,
     1, 0xFA12, 0x6674, 0,
     1, 0xFA15, 0x51DE, 0,
     1, 0xFA16, 0x732A, 0,
     1, 0xFA17, 0x76CA, 0,
     1, 0xFA18, 0x793C, 0,
     1, 0xFA19, 0x795E, 0,
     1, 0xFA1A, 0x7965, 0,
     1, 0xFA1B, 0x798F, 0,
     1, 0xFA1C, 0x9756, 0,
     1, 0xFA1D, 0x7CBE, 0,
     1, 0xFA1E, 0x7FBD, 0,
     1, 0xFA20, 0x8612, 0,
     1, 0xFA22, 0x8AF8, 0,
     1, 0xFA25, 0x9038, 0,
     1, 0xFA26, 0x90FD, 0,
     1, 0xFA2A, 0x98EF, 0,
     1, 0xFA2B, 0x98FC, 0,
     1, 0xFA2C, 0x9928, 0,
     1, 0xFA2D, 0x9DB4, 0,
     1, 0xFA30, 0x4FAE, 0,
     1, 0xFA31, 0x50E7, 0,
     1, 0xFA32, 0x514D, 0,
     1, 0xFA33, 0x52C9, 0,
     1, 0xFA34, 0x52E4, 0,
     1, 0xFA35, 0x5351, 0,
     1, 0xFA36, 0x559D, 0,
     1, 0xFA37, 0x5606, 0,
     1, 0xFA38, 0x5668, 0,
     1, 0xFA39, 0x5840, 0,
     1, 0xFA3A, 0x58A8, 0,
     1, 0xFA3B, 0x5C64, 0,
     1, 0xFA3C, 0x5C6E, 0,
     1, 0xFA3D, 0x6094, 0,
     1, 0xFA3E, 0x6168, 0,
     1, 0xFA3F, 0x618E, 0,
     1, 0xFA40, 0x61F2, 0,
     1, 0xFA41, 0x654F, 0,
     1, 0xFA42, 0x65E2, 0,
     1, 0xFA43, 0x6691, 0,
     1, 0xFA44, 0x6885, 0,
     1, 0xFA45, 0x6D77, 0,
     1, 0xFA46, 0x6E1A, 0,
     1, 0xFA47, 0x6F22, 0,
     1, 0xFA48, 0x716E, 0,
     1, 0xFA49, 0x722B, 0,
     1, 0xFA4A, 0x7422, 0,
     1, 0xFA4B, 0x7891, 0,
     1, 0xFA4C, 0x793E, 0,
     1, 0xFA4D, 0x7949, 0,
     1, 0xFA4E, 0x7948, 0,
     1, 0xFA4F, 0x7950, 0,
     1, 0xFA50, 0x7956, 0,
     1, 0xFA51, 0x795D, 0,
     1, 0xFA52, 0x798D, 0,
     1, 0xFA53, 0x798E, 0,
     1, 0xFA54, 0x7A40, 0,
     1, 0xFA55, 0x7A81, 0,
     1, 0xFA56, 0x7BC0, 0,
     1, 0xFA57, 0x7DF4, 0,
     1, 0xFA58, 0x7E09, 0,
     1, 0xFA59, 0x7E41, 0,
     1, 0xFA5A, 0x7F72, 0,
     1, 0xFA5B, 0x8005, 0,
     1, 0xFA5C, 0x81ED, 0,
     1, 0xFA5D, 0x8279, 0,
     1, 0xFA5E, 0x8279, 0,
     1, 0xFA5F, 0x8457, 0,
     1, 0xFA60, 0x8910, 0,
     1, 0xFA61, 0x8996, 0,
     1, 0xFA62, 0x8B01, 0,
     1, 0xFA63, 0x8B39, 0,
     1, 0xFA64, 0x8CD3, 0,
     1, 0xFA65, 0x8D08, 0,
     1, 0xFA66, 0x8FB6, 0,
     1, 0xFA67, 0x9038, 0,
     1, 0xFA68, 0x96E3, 0,
     1, 0xFA69, 0x97FF, 0,
     1, 0xFA6A, 0x983B, 0,
     16, 0xFB00, 0x0066, 0x0066, 0,
     16, 0xFB01, 0x0066, 0x0069, 0,
     16, 0xFB02, 0x0066, 0x006C, 0,
     16, 0xFB03, 0x0066, 0x0066, 0x0069, 0,
     16, 0xFB04, 0x0066, 0x0066, 0x006C, 0,
     16, 0xFB05, 0x017F, 0x0074, 0,
     16, 0xFB06, 0x0073, 0x0074, 0,
     16, 0xFB13, 0x0574, 0x0576, 0,
     16, 0xFB14, 0x0574, 0x0565, 0,
     16, 0xFB15, 0x0574, 0x056B, 0,
     16, 0xFB16, 0x057E, 0x0576, 0,
     16, 0xFB17, 0x0574, 0x056D, 0,
     1, 0xFB1D, 0x05D9, 0x05B4, 0,
     1, 0xFB1F, 0x05F2, 0x05B7, 0,
     2, 0xFB20, 0x05E2, 0,
     2, 0xFB21, 0x05D0, 0,
     2, 0xFB22, 0x05D3, 0,
     2, 0xFB23, 0x05D4, 0,
     2, 0xFB24, 0x05DB, 0,
     2, 0xFB25, 0x05DC, 0,
     2, 0xFB26, 0x05DD, 0,
     2, 0xFB27, 0x05E8, 0,
     2, 0xFB28, 0x05EA, 0,
     2, 0xFB29, 0x002B, 0,
     1, 0xFB2A, 0x05E9, 0x05C1, 0,
     1, 0xFB2B, 0x05E9, 0x05C2, 0,
     1, 0xFB2C, 0xFB49, 0x05C1, 0,
     1, 0xFB2D, 0xFB49, 0x05C2, 0,
     1, 0xFB2E, 0x05D0, 0x05B7, 0,
     1, 0xFB2F, 0x05D0, 0x05B8, 0,
     1, 0xFB30, 0x05D0, 0x05BC, 0,
     1, 0xFB31, 0x05D1, 0x05BC, 0,
     1, 0xFB32, 0x05D2, 0x05BC, 0,
     1, 0xFB33, 0x05D3, 0x05BC, 0,
     1, 0xFB34, 0x05D4, 0x05BC, 0,
     1, 0xFB35, 0x05D5, 0x05BC, 0,
     1, 0xFB36, 0x05D6, 0x05BC, 0,
     1, 0xFB38, 0x05D8, 0x05BC, 0,
     1, 0xFB39, 0x05D9, 0x05BC, 0,
     1, 0xFB3A, 0x05DA, 0x05BC, 0,
     1, 0xFB3B, 0x05DB, 0x05BC, 0,
     1, 0xFB3C, 0x05DC, 0x05BC, 0,
     1, 0xFB3E, 0x05DE, 0x05BC, 0,
     1, 0xFB40, 0x05E0, 0x05BC, 0,
     1, 0xFB41, 0x05E1, 0x05BC, 0,
     1, 0xFB43, 0x05E3, 0x05BC, 0,
     1, 0xFB44, 0x05E4, 0x05BC, 0,
     1, 0xFB46, 0x05E6, 0x05BC, 0,
     1, 0xFB47, 0x05E7, 0x05BC, 0,
     1, 0xFB48, 0x05E8, 0x05BC, 0,
     1, 0xFB49, 0x05E9, 0x05BC, 0,
     1, 0xFB4A, 0x05EA, 0x05BC, 0,
     1, 0xFB4B, 0x05D5, 0x05B9, 0,
     1, 0xFB4C, 0x05D1, 0x05BF, 0,
     1, 0xFB4D, 0x05DB, 0x05BF, 0,
     1, 0xFB4E, 0x05E4, 0x05BF, 0,
     16, 0xFB4F, 0x05D0, 0x05DC, 0,
     7, 0xFB50, 0x0671, 0,
     6, 0xFB51, 0x0671, 0,
     7, 0xFB52, 0x067B, 0,
     6, 0xFB53, 0x067B, 0,
     4, 0xFB54, 0x067B, 0,
     5, 0xFB55, 0x067B, 0,
     7, 0xFB56, 0x067E, 0,
     6, 0xFB57, 0x067E, 0,
     4, 0xFB58, 0x067E, 0,
     5, 0xFB59, 0x067E, 0,
     7, 0xFB5A, 0x0680, 0,
     6, 0xFB5B, 0x0680, 0,
     4, 0xFB5C, 0x0680, 0,
     5, 0xFB5D, 0x0680, 0,
     7, 0xFB5E, 0x067A, 0,
     6, 0xFB5F, 0x067A, 0,
     4, 0xFB60, 0x067A, 0,
     5, 0xFB61, 0x067A, 0,
     7, 0xFB62, 0x067F, 0,
     6, 0xFB63, 0x067F, 0,
     4, 0xFB64, 0x067F, 0,
     5, 0xFB65, 0x067F, 0,
     7, 0xFB66, 0x0679, 0,
     6, 0xFB67, 0x0679, 0,
     4, 0xFB68, 0x0679, 0,
     5, 0xFB69, 0x0679, 0,
     7, 0xFB6A, 0x06A4, 0,
     6, 0xFB6B, 0x06A4, 0,
     4, 0xFB6C, 0x06A4, 0,
     5, 0xFB6D, 0x06A4, 0,
     7, 0xFB6E, 0x06A6, 0,
     6, 0xFB6F, 0x06A6, 0,
     4, 0xFB70, 0x06A6, 0,
     5, 0xFB71, 0x06A6, 0,
     7, 0xFB72, 0x0684, 0,
     6, 0xFB73, 0x0684, 0,
     4, 0xFB74, 0x0684, 0,
     5, 0xFB75, 0x0684, 0,
     7, 0xFB76, 0x0683, 0,
     6, 0xFB77, 0x0683, 0,
     4, 0xFB78, 0x0683, 0,
     5, 0xFB79, 0x0683, 0,
     7, 0xFB7A, 0x0686, 0,
     6, 0xFB7B, 0x0686, 0,
     4, 0xFB7C, 0x0686, 0,
     5, 0xFB7D, 0x0686, 0,
     7, 0xFB7E, 0x0687, 0,
     6, 0xFB7F, 0x0687, 0,
     4, 0xFB80, 0x0687, 0,
     5, 0xFB81, 0x0687, 0,
     7, 0xFB82, 0x068D, 0,
     6, 0xFB83, 0x068D, 0,
     7, 0xFB84, 0x068C, 0,
     6, 0xFB85, 0x068C, 0,
     7, 0xFB86, 0x068E, 0,
     6, 0xFB87, 0x068E, 0,
     7, 0xFB88, 0x0688, 0,
     6, 0xFB89, 0x0688, 0,
     7, 0xFB8A, 0x0698, 0,
     6, 0xFB8B, 0x0698, 0,
     7, 0xFB8C, 0x0691, 0,
     6, 0xFB8D, 0x0691, 0,
     7, 0xFB8E, 0x06A9, 0,
     6, 0xFB8F, 0x06A9, 0,
     4, 0xFB90, 0x06A9, 0,
     5, 0xFB91, 0x06A9, 0,
     7, 0xFB92, 0x06AF, 0,
     6, 0xFB93, 0x06AF, 0,
     4, 0xFB94, 0x06AF, 0,
     5, 0xFB95, 0x06AF, 0,
     7, 0xFB96, 0x06B3, 0,
     6, 0xFB97, 0x06B3, 0,
     4, 0xFB98, 0x06B3, 0,
     5, 0xFB99, 0x06B3, 0,
     7, 0xFB9A, 0x06B1, 0,
     6, 0xFB9B, 0x06B1, 0,
     4, 0xFB9C, 0x06B1, 0,
     5, 0xFB9D, 0x06B1, 0,
     7, 0xFB9E, 0x06BA, 0,
     6, 0xFB9F, 0x06BA, 0,
     7, 0xFBA0, 0x06BB, 0,
     6, 0xFBA1, 0x06BB, 0,
     4, 0xFBA2, 0x06BB, 0,
     5, 0xFBA3, 0x06BB, 0,
     7, 0xFBA4, 0x06C0, 0,
     6, 0xFBA5, 0x06C0, 0,
     7, 0xFBA6, 0x06C1, 0,
     6, 0xFBA7, 0x06C1, 0,
     4, 0xFBA8, 0x06C1, 0,
     5, 0xFBA9, 0x06C1, 0,
     7, 0xFBAA, 0x06BE, 0,
     6, 0xFBAB, 0x06BE, 0,
     4, 0xFBAC, 0x06BE, 0,
     5, 0xFBAD, 0x06BE, 0,
     7, 0xFBAE, 0x06D2, 0,
     6, 0xFBAF, 0x06D2, 0,
     7, 0xFBB0, 0x06D3, 0,
     6, 0xFBB1, 0x06D3, 0,
     7, 0xFBD3, 0x06AD, 0,
     6, 0xFBD4, 0x06AD, 0,
     4, 0xFBD5, 0x06AD, 0,
     5, 0xFBD6, 0x06AD, 0,
     7, 0xFBD7, 0x06C7, 0,
     6, 0xFBD8, 0x06C7, 0,
     7, 0xFBD9, 0x06C6, 0,
     6, 0xFBDA, 0x06C6, 0,
     7, 0xFBDB, 0x06C8, 0,
     6, 0xFBDC, 0x06C8, 0,
     7, 0xFBDD, 0x0677, 0,
     7, 0xFBDE, 0x06CB, 0,
     6, 0xFBDF, 0x06CB, 0,
     7, 0xFBE0, 0x06C5, 0,
     6, 0xFBE1, 0x06C5, 0,
     7, 0xFBE2, 0x06C9, 0,
     6, 0xFBE3, 0x06C9, 0,
     7, 0xFBE4, 0x06D0, 0,
     6, 0xFBE5, 0x06D0, 0,
     4, 0xFBE6, 0x06D0, 0,
     5, 0xFBE7, 0x06D0, 0,
     4, 0xFBE8, 0x0649, 0,
     5, 0xFBE9, 0x0649, 0,
     7, 0xFBEA, 0x0626, 0x0627, 0,
     6, 0xFBEB, 0x0626, 0x0627, 0,
     7, 0xFBEC, 0x0626, 0x06D5, 0,
     6, 0xFBED, 0x0626, 0x06D5, 0,
     7, 0xFBEE, 0x0626, 0x0648, 0,
     6, 0xFBEF, 0x0626, 0x0648, 0,
     7, 0xFBF0, 0x0626, 0x06C7, 0,
     6, 0xFBF1, 0x0626, 0x06C7, 0,
     7, 0xFBF2, 0x0626, 0x06C6, 0,
     6, 0xFBF3, 0x0626, 0x06C6, 0,
     7, 0xFBF4, 0x0626, 0x06C8, 0,
     6, 0xFBF5, 0x0626, 0x06C8, 0,
     7, 0xFBF6, 0x0626, 0x06D0, 0,
     6, 0xFBF7, 0x0626, 0x06D0, 0,
     4, 0xFBF8, 0x0626, 0x06D0, 0,
     7, 0xFBF9, 0x0626, 0x0649, 0,
     6, 0xFBFA, 0x0626, 0x0649, 0,
     4, 0xFBFB, 0x0626, 0x0649, 0,
     7, 0xFBFC, 0x06CC, 0,
     6, 0xFBFD, 0x06CC, 0,
     4, 0xFBFE, 0x06CC, 0,
     5, 0xFBFF, 0x06CC, 0,
     7, 0xFC00, 0x0626, 0x062C, 0,
     7, 0xFC01, 0x0626, 0x062D, 0,
     7, 0xFC02, 0x0626, 0x0645, 0,
     7, 0xFC03, 0x0626, 0x0649, 0,
     7, 0xFC04, 0x0626, 0x064A, 0,
     7, 0xFC05, 0x0628, 0x062C, 0,
     7, 0xFC06, 0x0628, 0x062D, 0,
     7, 0xFC07, 0x0628, 0x062E, 0,
     7, 0xFC08, 0x0628, 0x0645, 0,
     7, 0xFC09, 0x0628, 0x0649, 0,
     7, 0xFC0A, 0x0628, 0x064A, 0,
     7, 0xFC0B, 0x062A, 0x062C, 0,
     7, 0xFC0C, 0x062A, 0x062D, 0,
     7, 0xFC0D, 0x062A, 0x062E, 0,
     7, 0xFC0E, 0x062A, 0x0645, 0,
     7, 0xFC0F, 0x062A, 0x0649, 0,
     7, 0xFC10, 0x062A, 0x064A, 0,
     7, 0xFC11, 0x062B, 0x062C, 0,
     7, 0xFC12, 0x062B, 0x0645, 0,
     7, 0xFC13, 0x062B, 0x0649, 0,
     7, 0xFC14, 0x062B, 0x064A, 0,
     7, 0xFC15, 0x062C, 0x062D, 0,
     7, 0xFC16, 0x062C, 0x0645, 0,
     7, 0xFC17, 0x062D, 0x062C, 0,
     7, 0xFC18, 0x062D, 0x0645, 0,
     7, 0xFC19, 0x062E, 0x062C, 0,
     7, 0xFC1A, 0x062E, 0x062D, 0,
     7, 0xFC1B, 0x062E, 0x0645, 0,
     7, 0xFC1C, 0x0633, 0x062C, 0,
     7, 0xFC1D, 0x0633, 0x062D, 0,
     7, 0xFC1E, 0x0633, 0x062E, 0,
     7, 0xFC1F, 0x0633, 0x0645, 0,
     7, 0xFC20, 0x0635, 0x062D, 0,
     7, 0xFC21, 0x0635, 0x0645, 0,
     7, 0xFC22, 0x0636, 0x062C, 0,
     7, 0xFC23, 0x0636, 0x062D, 0,
     7, 0xFC24, 0x0636, 0x062E, 0,
     7, 0xFC25, 0x0636, 0x0645, 0,
     7, 0xFC26, 0x0637, 0x062D, 0,
     7, 0xFC27, 0x0637, 0x0645, 0,
     7, 0xFC28, 0x0638, 0x0645, 0,
     7, 0xFC29, 0x0639, 0x062C, 0,
     7, 0xFC2A, 0x0639, 0x0645, 0,
     7, 0xFC2B, 0x063A, 0x062C, 0,
     7, 0xFC2C, 0x063A, 0x0645, 0,
     7, 0xFC2D, 0x0641, 0x062C, 0,
     7, 0xFC2E, 0x0641, 0x062D, 0,
     7, 0xFC2F, 0x0641, 0x062E, 0,
     7, 0xFC30, 0x0641, 0x0645, 0,
     7, 0xFC31, 0x0641, 0x0649, 0,
     7, 0xFC32, 0x0641, 0x064A, 0,
     7, 0xFC33, 0x0642, 0x062D, 0,
     7, 0xFC34, 0x0642, 0x0645, 0,
     7, 0xFC35, 0x0642, 0x0649, 0,
     7, 0xFC36, 0x0642, 0x064A, 0,
     7, 0xFC37, 0x0643, 0x0627, 0,
     7, 0xFC38, 0x0643, 0x062C, 0,
     7, 0xFC39, 0x0643, 0x062D, 0,
     7, 0xFC3A, 0x0643, 0x062E, 0,
     7, 0xFC3B, 0x0643, 0x0644, 0,
     7, 0xFC3C, 0x0643, 0x0645, 0,
     7, 0xFC3D, 0x0643, 0x0649, 0,
     7, 0xFC3E, 0x0643, 0x064A, 0,
     7, 0xFC3F, 0x0644, 0x062C, 0,
     7, 0xFC40, 0x0644, 0x062D, 0,
     7, 0xFC41, 0x0644, 0x062E, 0,
     7, 0xFC42, 0x0644, 0x0645, 0,
     7, 0xFC43, 0x0644, 0x0649, 0,
     7, 0xFC44, 0x0644, 0x064A, 0,
     7, 0xFC45, 0x0645, 0x062C, 0,
     7, 0xFC46, 0x0645, 0x062D, 0,
     7, 0xFC47, 0x0645, 0x062E, 0,
     7, 0xFC48, 0x0645, 0x0645, 0,
     7, 0xFC49, 0x0645, 0x0649, 0,
     7, 0xFC4A, 0x0645, 0x064A, 0,
     7, 0xFC4B, 0x0646, 0x062C, 0,
     7, 0xFC4C, 0x0646, 0x062D, 0,
     7, 0xFC4D, 0x0646, 0x062E, 0,
     7, 0xFC4E, 0x0646, 0x0645, 0,
     7, 0xFC4F, 0x0646, 0x0649, 0,
     7, 0xFC50, 0x0646, 0x064A, 0,
     7, 0xFC51, 0x0647, 0x062C, 0,
     7, 0xFC52, 0x0647, 0x0645, 0,
     7, 0xFC53, 0x0647, 0x0649, 0,
     7, 0xFC54, 0x0647, 0x064A, 0,
     7, 0xFC55, 0x064A, 0x062C, 0,
     7, 0xFC56, 0x064A, 0x062D, 0,
     7, 0xFC57, 0x064A, 0x062E, 0,
     7, 0xFC58, 0x064A, 0x0645, 0,
     7, 0xFC59, 0x064A, 0x0649, 0,
     7, 0xFC5A, 0x064A, 0x064A, 0,
     7, 0xFC5B, 0x0630, 0x0670, 0,
     7, 0xFC5C, 0x0631, 0x0670, 0,
     7, 0xFC5D, 0x0649, 0x0670, 0,
     7, 0xFC5E, 0x0020, 0x064C, 0x0651, 0,
     7, 0xFC5F, 0x0020, 0x064D, 0x0651, 0,
     7, 0xFC60, 0x0020, 0x064E, 0x0651, 0,
     7, 0xFC61, 0x0020, 0x064F, 0x0651, 0,
     7, 0xFC62, 0x0020, 0x0650, 0x0651, 0,
     7, 0xFC63, 0x0020, 0x0651, 0x0670, 0,
     6, 0xFC64, 0x0626, 0x0631, 0,
     6, 0xFC65, 0x0626, 0x0632, 0,
     6, 0xFC66, 0x0626, 0x0645, 0,
     6, 0xFC67, 0x0626, 0x0646, 0,
     6, 0xFC68, 0x0626, 0x0649, 0,
     6, 0xFC69, 0x0626, 0x064A, 0,
     6, 0xFC6A, 0x0628, 0x0631, 0,
     6, 0xFC6B, 0x0628, 0x0632, 0,
     6, 0xFC6C, 0x0628, 0x0645, 0,
     6, 0xFC6D, 0x0628, 0x0646, 0,
     6, 0xFC6E, 0x0628, 0x0649, 0,
     6, 0xFC6F, 0x0628, 0x064A, 0,
     6, 0xFC70, 0x062A, 0x0631, 0,
     6, 0xFC71, 0x062A, 0x0632, 0,
     6, 0xFC72, 0x062A, 0x0645, 0,
     6, 0xFC73, 0x062A, 0x0646, 0,
     6, 0xFC74, 0x062A, 0x0649, 0,
     6, 0xFC75, 0x062A, 0x064A, 0,
     6, 0xFC76, 0x062B, 0x0631, 0,
     6, 0xFC77, 0x062B, 0x0632, 0,
     6, 0xFC78, 0x062B, 0x0645, 0,
     6, 0xFC79, 0x062B, 0x0646, 0,
     6, 0xFC7A, 0x062B, 0x0649, 0,
     6, 0xFC7B, 0x062B, 0x064A, 0,
     6, 0xFC7C, 0x0641, 0x0649, 0,
     6, 0xFC7D, 0x0641, 0x064A, 0,
     6, 0xFC7E, 0x0642, 0x0649, 0,
     6, 0xFC7F, 0x0642, 0x064A, 0,
     6, 0xFC80, 0x0643, 0x0627, 0,
     6, 0xFC81, 0x0643, 0x0644, 0,
     6, 0xFC82, 0x0643, 0x0645, 0,
     6, 0xFC83, 0x0643, 0x0649, 0,
     6, 0xFC84, 0x0643, 0x064A, 0,
     6, 0xFC85, 0x0644, 0x0645, 0,
     6, 0xFC86, 0x0644, 0x0649, 0,
     6, 0xFC87, 0x0644, 0x064A, 0,
     6, 0xFC88, 0x0645, 0x0627, 0,
     6, 0xFC89, 0x0645, 0x0645, 0,
     6, 0xFC8A, 0x0646, 0x0631, 0,
     6, 0xFC8B, 0x0646, 0x0632, 0,
     6, 0xFC8C, 0x0646, 0x0645, 0,
     6, 0xFC8D, 0x0646, 0x0646, 0,
     6, 0xFC8E, 0x0646, 0x0649, 0,
     6, 0xFC8F, 0x0646, 0x064A, 0,
     6, 0xFC90, 0x0649, 0x0670, 0,
     6, 0xFC91, 0x064A, 0x0631, 0,
     6, 0xFC92, 0x064A, 0x0632, 0,
     6, 0xFC93, 0x064A, 0x0645, 0,
     6, 0xFC94, 0x064A, 0x0646, 0,
     6, 0xFC95, 0x064A, 0x0649, 0,
     6, 0xFC96, 0x064A, 0x064A, 0,
     4, 0xFC97, 0x0626, 0x062C, 0,
     4, 0xFC98, 0x0626, 0x062D, 0,
     4, 0xFC99, 0x0626, 0x062E, 0,
     4, 0xFC9A, 0x0626, 0x0645, 0,
     4, 0xFC9B, 0x0626, 0x0647, 0,
     4, 0xFC9C, 0x0628, 0x062C, 0,
     4, 0xFC9D, 0x0628, 0x062D, 0,
     4, 0xFC9E, 0x0628, 0x062E, 0,
     4, 0xFC9F, 0x0628, 0x0645, 0,
     4, 0xFCA0, 0x0628, 0x0647, 0,
     4, 0xFCA1, 0x062A, 0x062C, 0,
     4, 0xFCA2, 0x062A, 0x062D, 0,
     4, 0xFCA3, 0x062A, 0x062E, 0,
     4, 0xFCA4, 0x062A, 0x0645, 0,
     4, 0xFCA5, 0x062A, 0x0647, 0,
     4, 0xFCA6, 0x062B, 0x0645, 0,
     4, 0xFCA7, 0x062C, 0x062D, 0,
     4, 0xFCA8, 0x062C, 0x0645, 0,
     4, 0xFCA9, 0x062D, 0x062C, 0,
     4, 0xFCAA, 0x062D, 0x0645, 0,
     4, 0xFCAB, 0x062E, 0x062C, 0,
     4, 0xFCAC, 0x062E, 0x0645, 0,
     4, 0xFCAD, 0x0633, 0x062C, 0,
     4, 0xFCAE, 0x0633, 0x062D, 0,
     4, 0xFCAF, 0x0633, 0x062E, 0,
     4, 0xFCB0, 0x0633, 0x0645, 0,
     4, 0xFCB1, 0x0635, 0x062D, 0,
     4, 0xFCB2, 0x0635, 0x062E, 0,
     4, 0xFCB3, 0x0635, 0x0645, 0,
     4, 0xFCB4, 0x0636, 0x062C, 0,
     4, 0xFCB5, 0x0636, 0x062D, 0,
     4, 0xFCB6, 0x0636, 0x062E, 0,
     4, 0xFCB7, 0x0636, 0x0645, 0,
     4, 0xFCB8, 0x0637, 0x062D, 0,
     4, 0xFCB9, 0x0638, 0x0645, 0,
     4, 0xFCBA, 0x0639, 0x062C, 0,
     4, 0xFCBB, 0x0639, 0x0645, 0,
     4, 0xFCBC, 0x063A, 0x062C, 0,
     4, 0xFCBD, 0x063A, 0x0645, 0,
     4, 0xFCBE, 0x0641, 0x062C, 0,
     4, 0xFCBF, 0x0641, 0x062D, 0,
     4, 0xFCC0, 0x0641, 0x062E, 0,
     4, 0xFCC1, 0x0641, 0x0645, 0,
     4, 0xFCC2, 0x0642, 0x062D, 0,
     4, 0xFCC3, 0x0642, 0x0645, 0,
     4, 0xFCC4, 0x0643, 0x062C, 0,
     4, 0xFCC5, 0x0643, 0x062D, 0,
     4, 0xFCC6, 0x0643, 0x062E, 0,
     4, 0xFCC7, 0x0643, 0x0644, 0,
     4, 0xFCC8, 0x0643, 0x0645, 0,
     4, 0xFCC9, 0x0644, 0x062C, 0,
     4, 0xFCCA, 0x0644, 0x062D, 0,
     4, 0xFCCB, 0x0644, 0x062E, 0,
     4, 0xFCCC, 0x0644, 0x0645, 0,
     4, 0xFCCD, 0x0644, 0x0647, 0,
     4, 0xFCCE, 0x0645, 0x062C, 0,
     4, 0xFCCF, 0x0645, 0x062D, 0,
     4, 0xFCD0, 0x0645, 0x062E, 0,
     4, 0xFCD1, 0x0645, 0x0645, 0,
     4, 0xFCD2, 0x0646, 0x062C, 0,
     4, 0xFCD3, 0x0646, 0x062D, 0,
     4, 0xFCD4, 0x0646, 0x062E, 0,
     4, 0xFCD5, 0x0646, 0x0645, 0,
     4, 0xFCD6, 0x0646, 0x0647, 0,
     4, 0xFCD7, 0x0647, 0x062C, 0,
     4, 0xFCD8, 0x0647, 0x0645, 0,
     4, 0xFCD9, 0x0647, 0x0670, 0,
     4, 0xFCDA, 0x064A, 0x062C, 0,
     4, 0xFCDB, 0x064A, 0x062D, 0,
     4, 0xFCDC, 0x064A, 0x062E, 0,
     4, 0xFCDD, 0x064A, 0x0645, 0,
     4, 0xFCDE, 0x064A, 0x0647, 0,
     5, 0xFCDF, 0x0626, 0x0645, 0,
     5, 0xFCE0, 0x0626, 0x0647, 0,
     5, 0xFCE1, 0x0628, 0x0645, 0,
     5, 0xFCE2, 0x0628, 0x0647, 0,
     5, 0xFCE3, 0x062A, 0x0645, 0,
     5, 0xFCE4, 0x062A, 0x0647, 0,
     5, 0xFCE5, 0x062B, 0x0645, 0,
     5, 0xFCE6, 0x062B, 0x0647, 0,
     5, 0xFCE7, 0x0633, 0x0645, 0,
     5, 0xFCE8, 0x0633, 0x0647, 0,
     5, 0xFCE9, 0x0634, 0x0645, 0,
     5, 0xFCEA, 0x0634, 0x0647, 0,
     5, 0xFCEB, 0x0643, 0x0644, 0,
     5, 0xFCEC, 0x0643, 0x0645, 0,
     5, 0xFCED, 0x0644, 0x0645, 0,
     5, 0xFCEE, 0x0646, 0x0645, 0,
     5, 0xFCEF, 0x0646, 0x0647, 0,
     5, 0xFCF0, 0x064A, 0x0645, 0,
     5, 0xFCF1, 0x064A, 0x0647, 0,
     5, 0xFCF2, 0x0640, 0x064E, 0x0651, 0,
     5, 0xFCF3, 0x0640, 0x064F, 0x0651, 0,
     5, 0xFCF4, 0x0640, 0x0650, 0x0651, 0,
     7, 0xFCF5, 0x0637, 0x0649, 0,
     7, 0xFCF6, 0x0637, 0x064A, 0,
     7, 0xFCF7, 0x0639, 0x0649, 0,
     7, 0xFCF8, 0x0639, 0x064A, 0,
     7, 0xFCF9, 0x063A, 0x0649, 0,
     7, 0xFCFA, 0x063A, 0x064A, 0,
     7, 0xFCFB, 0x0633, 0x0649, 0,
     7, 0xFCFC, 0x0633, 0x064A, 0,
     7, 0xFCFD, 0x0634, 0x0649, 0,
     7, 0xFCFE, 0x0634, 0x064A, 0,
     7, 0xFCFF, 0x062D, 0x0649, 0,
     7, 0xFD00, 0x062D, 0x064A, 0,
     7, 0xFD01, 0x062C, 0x0649, 0,
     7, 0xFD02, 0x062C, 0x064A, 0,
     7, 0xFD03, 0x062E, 0x0649, 0,
     7, 0xFD04, 0x062E, 0x064A, 0,
     7, 0xFD05, 0x0635, 0x0649, 0,
     7, 0xFD06, 0x0635, 0x064A, 0,
     7, 0xFD07, 0x0636, 0x0649, 0,
     7, 0xFD08, 0x0636, 0x064A, 0,
     7, 0xFD09, 0x0634, 0x062C, 0,
     7, 0xFD0A, 0x0634, 0x062D, 0,
     7, 0xFD0B, 0x0634, 0x062E, 0,
     7, 0xFD0C, 0x0634, 0x0645, 0,
     7, 0xFD0D, 0x0634, 0x0631, 0,
     7, 0xFD0E, 0x0633, 0x0631, 0,
     7, 0xFD0F, 0x0635, 0x0631, 0,
     7, 0xFD10, 0x0636, 0x0631, 0,
     6, 0xFD11, 0x0637, 0x0649, 0,
     6, 0xFD12, 0x0637, 0x064A, 0,
     6, 0xFD13, 0x0639, 0x0649, 0,
     6, 0xFD14, 0x0639, 0x064A, 0,
     6, 0xFD15, 0x063A, 0x0649, 0,
     6, 0xFD16, 0x063A, 0x064A, 0,
     6, 0xFD17, 0x0633, 0x0649, 0,
     6, 0xFD18, 0x0633, 0x064A, 0,
     6, 0xFD19, 0x0634, 0x0649, 0,
     6, 0xFD1A, 0x0634, 0x064A, 0,
     6, 0xFD1B, 0x062D, 0x0649, 0,
     6, 0xFD1C, 0x062D, 0x064A, 0,
     6, 0xFD1D, 0x062C, 0x0649, 0,
     6, 0xFD1E, 0x062C, 0x064A, 0,
     6, 0xFD1F, 0x062E, 0x0649, 0,
     6, 0xFD20, 0x062E, 0x064A, 0,
     6, 0xFD21, 0x0635, 0x0649, 0,
     6, 0xFD22, 0x0635, 0x064A, 0,
     6, 0xFD23, 0x0636, 0x0649, 0,
     6, 0xFD24, 0x0636, 0x064A, 0,
     6, 0xFD25, 0x0634, 0x062C, 0,
     6, 0xFD26, 0x0634, 0x062D, 0,
     6, 0xFD27, 0x0634, 0x062E, 0,
     6, 0xFD28, 0x0634, 0x0645, 0,
     6, 0xFD29, 0x0634, 0x0631, 0,
     6, 0xFD2A, 0x0633, 0x0631, 0,
     6, 0xFD2B, 0x0635, 0x0631, 0,
     6, 0xFD2C, 0x0636, 0x0631, 0,
     4, 0xFD2D, 0x0634, 0x062C, 0,
     4, 0xFD2E, 0x0634, 0x062D, 0,
     4, 0xFD2F, 0x0634, 0x062E, 0,
     4, 0xFD30, 0x0634, 0x0645, 0,
     4, 0xFD31, 0x0633, 0x0647, 0,
     4, 0xFD32, 0x0634, 0x0647, 0,
     4, 0xFD33, 0x0637, 0x0645, 0,
     5, 0xFD34, 0x0633, 0x062C, 0,
     5, 0xFD35, 0x0633, 0x062D, 0,
     5, 0xFD36, 0x0633, 0x062E, 0,
     5, 0xFD37, 0x0634, 0x062C, 0,
     5, 0xFD38, 0x0634, 0x062D, 0,
     5, 0xFD39, 0x0634, 0x062E, 0,
     5, 0xFD3A, 0x0637, 0x0645, 0,
     5, 0xFD3B, 0x0638, 0x0645, 0,
     6, 0xFD3C, 0x0627, 0x064B, 0,
     7, 0xFD3D, 0x0627, 0x064B, 0,
     4, 0xFD50, 0x062A, 0x062C, 0x0645, 0,
     6, 0xFD51, 0x062A, 0x062D, 0x062C, 0,
     4, 0xFD52, 0x062A, 0x062D, 0x062C, 0,
     4, 0xFD53, 0x062A, 0x062D, 0x0645, 0,
     4, 0xFD54, 0x062A, 0x062E, 0x0645, 0,
     4, 0xFD55, 0x062A, 0x0645, 0x062C, 0,
     4, 0xFD56, 0x062A, 0x0645, 0x062D, 0,
     4, 0xFD57, 0x062A, 0x0645, 0x062E, 0,
     6, 0xFD58, 0x062C, 0x0645, 0x062D, 0,
     4, 0xFD59, 0x062C, 0x0645, 0x062D, 0,
     6, 0xFD5A, 0x062D, 0x0645, 0x064A, 0,
     6, 0xFD5B, 0x062D, 0x0645, 0x0649, 0,
     4, 0xFD5C, 0x0633, 0x062D, 0x062C, 0,
     4, 0xFD5D, 0x0633, 0x062C, 0x062D, 0,
     6, 0xFD5E, 0x0633, 0x062C, 0x0649, 0,
     6, 0xFD5F, 0x0633, 0x0645, 0x062D, 0,
     4, 0xFD60, 0x0633, 0x0645, 0x062D, 0,
     4, 0xFD61, 0x0633, 0x0645, 0x062C, 0,
     6, 0xFD62, 0x0633, 0x0645, 0x0645, 0,
     4, 0xFD63, 0x0633, 0x0645, 0x0645, 0,
     6, 0xFD64, 0x0635, 0x062D, 0x062D, 0,
     4, 0xFD65, 0x0635, 0x062D, 0x062D, 0,
     6, 0xFD66, 0x0635, 0x0645, 0x0645, 0,
     6, 0xFD67, 0x0634, 0x062D, 0x0645, 0,
     4, 0xFD68, 0x0634, 0x062D, 0x0645, 0,
     6, 0xFD69, 0x0634, 0x062C, 0x064A, 0,
     6, 0xFD6A, 0x0634, 0x0645, 0x062E, 0,
     4, 0xFD6B, 0x0634, 0x0645, 0x062E, 0,
     6, 0xFD6C, 0x0634, 0x0645, 0x0645, 0,
     4, 0xFD6D, 0x0634, 0x0645, 0x0645, 0,
     6, 0xFD6E, 0x0636, 0x062D, 0x0649, 0,
     6, 0xFD6F, 0x0636, 0x062E, 0x0645, 0,
     4, 0xFD70, 0x0636, 0x062E, 0x0645, 0,
     6, 0xFD71, 0x0637, 0x0645, 0x062D, 0,
     4, 0xFD72, 0x0637, 0x0645, 0x062D, 0,
     4, 0xFD73, 0x0637, 0x0645, 0x0645, 0,
     6, 0xFD74, 0x0637, 0x0645, 0x064A, 0,
     6, 0xFD75, 0x0639, 0x062C, 0x0645, 0,
     6, 0xFD76, 0x0639, 0x0645, 0x0645, 0,
     4, 0xFD77, 0x0639, 0x0645, 0x0645, 0,
     6, 0xFD78, 0x0639, 0x0645, 0x0649, 0,
     6, 0xFD79, 0x063A, 0x0645, 0x0645, 0,
     6, 0xFD7A, 0x063A, 0x0645, 0x064A, 0,
     6, 0xFD7B, 0x063A, 0x0645, 0x0649, 0,
     6, 0xFD7C, 0x0641, 0x062E, 0x0645, 0,
     4, 0xFD7D, 0x0641, 0x062E, 0x0645, 0,
     6, 0xFD7E, 0x0642, 0x0645, 0x062D, 0,
     6, 0xFD7F, 0x0642, 0x0645, 0x0645, 0,
     6, 0xFD80, 0x0644, 0x062D, 0x0645, 0,
     6, 0xFD81, 0x0644, 0x062D, 0x064A, 0,
     6, 0xFD82, 0x0644, 0x062D, 0x0649, 0,
     4, 0xFD83, 0x0644, 0x062C, 0x062C, 0,
     6, 0xFD84, 0x0644, 0x062C, 0x062C, 0,
     6, 0xFD85, 0x0644, 0x062E, 0x0645, 0,
     4, 0xFD86, 0x0644, 0x062E, 0x0645, 0,
     6, 0xFD87, 0x0644, 0x0645, 0x062D, 0,
     4, 0xFD88, 0x0644, 0x0645, 0x062D, 0,
     4, 0xFD89, 0x0645, 0x062D, 0x062C, 0,
     4, 0xFD8A, 0x0645, 0x062D, 0x0645, 0,
     6, 0xFD8B, 0x0645, 0x062D, 0x064A, 0,
     4, 0xFD8C, 0x0645, 0x062C, 0x062D, 0,
     4, 0xFD8D, 0x0645, 0x062C, 0x0645, 0,
     4, 0xFD8E, 0x0645, 0x062E, 0x062C, 0,
     4, 0xFD8F, 0x0645, 0x062E, 0x0645, 0,
     4, 0xFD92, 0x0645, 0x062C, 0x062E, 0,
     4, 0xFD93, 0x0647, 0x0645, 0x062C, 0,
     4, 0xFD94, 0x0647, 0x0645, 0x0645, 0,
     4, 0xFD95, 0x0646, 0x062D, 0x0645, 0,
     6, 0xFD96, 0x0646, 0x062D, 0x0649, 0,
     6, 0xFD97, 0x0646, 0x062C, 0x0645, 0,
     4, 0xFD98, 0x0646, 0x062C, 0x0645, 0,
     6, 0xFD99, 0x0646, 0x062C, 0x0649, 0,
     6, 0xFD9A, 0x0646, 0x0645, 0x064A, 0,
     6, 0xFD9B, 0x0646, 0x0645, 0x0649, 0,
     6, 0xFD9C, 0x064A, 0x0645, 0x0645, 0,
     4, 0xFD9D, 0x064A, 0x0645, 0x0645, 0,
     6, 0xFD9E, 0x0628, 0x062E, 0x064A, 0,
     6, 0xFD9F, 0x062A, 0x062C, 0x064A, 0,
     6, 0xFDA0, 0x062A, 0x062C, 0x0649, 0,
     6, 0xFDA1, 0x062A, 0x062E, 0x064A, 0,
     6, 0xFDA2, 0x062A, 0x062E, 0x0649, 0,
     6, 0xFDA3, 0x062A, 0x0645, 0x064A, 0,
     6, 0xFDA4, 0x062A, 0x0645, 0x0649, 0,
     6, 0xFDA5, 0x062C, 0x0645, 0x064A, 0,
     6, 0xFDA6, 0x062C, 0x062D, 0x0649, 0,
     6, 0xFDA7, 0x062C, 0x0645, 0x0649, 0,
     6, 0xFDA8, 0x0633, 0x062E, 0x0649, 0,
     6, 0xFDA9, 0x0635, 0x062D, 0x064A, 0,
     6, 0xFDAA, 0x0634, 0x062D, 0x064A, 0,
     6, 0xFDAB, 0x0636, 0x062D, 0x064A, 0,
     6, 0xFDAC, 0x0644, 0x062C, 0x064A, 0,
     6, 0xFDAD, 0x0644, 0x0645, 0x064A, 0,
     6, 0xFDAE, 0x064A, 0x062D, 0x064A, 0,
     6, 0xFDAF, 0x064A, 0x062C, 0x064A, 0,
     6, 0xFDB0, 0x064A, 0x0645, 0x064A, 0,
     6, 0xFDB1, 0x0645, 0x0645, 0x064A, 0,
     6, 0xFDB2, 0x0642, 0x0645, 0x064A, 0,
     6, 0xFDB3, 0x0646, 0x062D, 0x064A, 0,
     4, 0xFDB4, 0x0642, 0x0645, 0x062D, 0,
     4, 0xFDB5, 0x0644, 0x062D, 0x0645, 0,
     6, 0xFDB6, 0x0639, 0x0645, 0x064A, 0,
     6, 0xFDB7, 0x0643, 0x0645, 0x064A, 0,
     4, 0xFDB8, 0x0646, 0x062C, 0x062D, 0,
     6, 0xFDB9, 0x0645, 0x062E, 0x064A, 0,
     4, 0xFDBA, 0x0644, 0x062C, 0x0645, 0,
     6, 0xFDBB, 0x0643, 0x0645, 0x0645, 0,
     6, 0xFDBC, 0x0644, 0x062C, 0x0645, 0,
     6, 0xFDBD, 0x0646, 0x062C, 0x062D, 0,
     6, 0xFDBE, 0x062C, 0x062D, 0x064A, 0,
     6, 0xFDBF, 0x062D, 0x062C, 0x064A, 0,
     6, 0xFDC0, 0x0645, 0x062C, 0x064A, 0,
     6, 0xFDC1, 0x0641, 0x0645, 0x064A, 0,
     6, 0xFDC2, 0x0628, 0x062D, 0x064A, 0,
     4, 0xFDC3, 0x0643, 0x0645, 0x0645, 0,
     4, 0xFDC4, 0x0639, 0x062C, 0x0645, 0,
     4, 0xFDC5, 0x0635, 0x0645, 0x0645, 0,
     6, 0xFDC6, 0x0633, 0x062E, 0x064A, 0,
     6, 0xFDC7, 0x0646, 0x062C, 0x064A, 0,
     7, 0xFDF0, 0x0635, 0x0644, 0x06D2, 0,
     7, 0xFDF1, 0x0642, 0x0644, 0x06D2, 0,
     7, 0xFDF2, 0x0627, 0x0644, 0x0644, 0x0647, 0,
     7, 0xFDF3, 0x0627, 0x0643, 0x0628, 0x0631, 0,
     7, 0xFDF4, 0x0645, 0x062D, 0x0645, 0x062F, 0,
     7, 0xFDF5, 0x0635, 0x0644, 0x0639, 0x0645, 0,
     7, 0xFDF6, 0x0631, 0x0633, 0x0648, 0x0644, 0,
     7, 0xFDF7, 0x0639, 0x0644, 0x064A, 0x0647, 0,
     7, 0xFDF8, 0x0648, 0x0633, 0x0644, 0x0645, 0,
     7, 0xFDF9, 0x0635, 0x0644, 0x0649, 0,
     7, 0xFDFA, 0x0635, 0x0644, 0x0649, 0x0020, 0x0627, 0x0644, 0x0644, 0x0647, 0x0020, 0x0639, 0x0644, 0x064A, 0x0647, 0x0020, 0x0648, 0x0633, 0x0644, 0x0645, 0,
     7, 0xFDFB, 0x062C, 0x0644, 0x0020, 0x062C, 0x0644, 0x0627, 0x0644, 0x0647, 0,
     7, 0xFDFC, 0x0631, 0x06CC, 0x0627, 0x0644, 0,
     11, 0xFE30, 0x2025, 0,
     11, 0xFE31, 0x2014, 0,
     11, 0xFE32, 0x2013, 0,
     11, 0xFE33, 0x005F, 0,
     11, 0xFE34, 0x005F, 0,
     11, 0xFE35, 0x0028, 0,
     11, 0xFE36, 0x0029, 0,
     11, 0xFE37, 0x007B, 0,
     11, 0xFE38, 0x007D, 0,
     11, 0xFE39, 0x3014, 0,
     11, 0xFE3A, 0x3015, 0,
     11, 0xFE3B, 0x3010, 0,
     11, 0xFE3C, 0x3011, 0,
     11, 0xFE3D, 0x300A, 0,
     11, 0xFE3E, 0x300B, 0,
     11, 0xFE3F, 0x3008, 0,
     11, 0xFE40, 0x3009, 0,
     11, 0xFE41, 0x300C, 0,
     11, 0xFE42, 0x300D, 0,
     11, 0xFE43, 0x300E, 0,
     11, 0xFE44, 0x300F, 0,
     16, 0xFE49, 0x203E, 0,
     16, 0xFE4A, 0x203E, 0,
     16, 0xFE4B, 0x203E, 0,
     16, 0xFE4C, 0x203E, 0,
     16, 0xFE4D, 0x005F, 0,
     16, 0xFE4E, 0x005F, 0,
     16, 0xFE4F, 0x005F, 0,
     14, 0xFE50, 0x002C, 0,
     14, 0xFE51, 0x3001, 0,
     14, 0xFE52, 0x002E, 0,
     14, 0xFE54, 0x003B, 0,
     14, 0xFE55, 0x003A, 0,
     14, 0xFE56, 0x003F, 0,
     14, 0xFE57, 0x0021, 0,
     14, 0xFE58, 0x2014, 0,
     14, 0xFE59, 0x0028, 0,
     14, 0xFE5A, 0x0029, 0,
     14, 0xFE5B, 0x007B, 0,
     14, 0xFE5C, 0x007D, 0,
     14, 0xFE5D, 0x3014, 0,
     14, 0xFE5E, 0x3015, 0,
     14, 0xFE5F, 0x0023, 0,
     14, 0xFE60, 0x0026, 0,
     14, 0xFE61, 0x002A, 0,
     14, 0xFE62, 0x002B, 0,
     14, 0xFE63, 0x002D, 0,
     14, 0xFE64, 0x003C, 0,
     14, 0xFE65, 0x003E, 0,
     14, 0xFE66, 0x003D, 0,
     14, 0xFE68, 0x005C, 0,
     14, 0xFE69, 0x0024, 0,
     14, 0xFE6A, 0x0025, 0,
     14, 0xFE6B, 0x0040, 0,
     7, 0xFE70, 0x0020, 0x064B, 0,
     5, 0xFE71, 0x0640, 0x064B, 0,
     7, 0xFE72, 0x0020, 0x064C, 0,
     7, 0xFE74, 0x0020, 0x064D, 0,
     7, 0xFE76, 0x0020, 0x064E, 0,
     5, 0xFE77, 0x0640, 0x064E, 0,
     7, 0xFE78, 0x0020, 0x064F, 0,
     5, 0xFE79, 0x0640, 0x064F, 0,
     7, 0xFE7A, 0x0020, 0x0650, 0,
     5, 0xFE7B, 0x0640, 0x0650, 0,
     7, 0xFE7C, 0x0020, 0x0651, 0,
     5, 0xFE7D, 0x0640, 0x0651, 0,
     7, 0xFE7E, 0x0020, 0x0652, 0,
     5, 0xFE7F, 0x0640, 0x0652, 0,
     7, 0xFE80, 0x0621, 0,
     7, 0xFE81, 0x0622, 0,
     6, 0xFE82, 0x0622, 0,
     7, 0xFE83, 0x0623, 0,
     6, 0xFE84, 0x0623, 0,
     7, 0xFE85, 0x0624, 0,
     6, 0xFE86, 0x0624, 0,
     7, 0xFE87, 0x0625, 0,
     6, 0xFE88, 0x0625, 0,
     7, 0xFE89, 0x0626, 0,
     6, 0xFE8A, 0x0626, 0,
     4, 0xFE8B, 0x0626, 0,
     5, 0xFE8C, 0x0626, 0,
     7, 0xFE8D, 0x0627, 0,
     6, 0xFE8E, 0x0627, 0,
     7, 0xFE8F, 0x0628, 0,
     6, 0xFE90, 0x0628, 0,
     4, 0xFE91, 0x0628, 0,
     5, 0xFE92, 0x0628, 0,
     7, 0xFE93, 0x0629, 0,
     6, 0xFE94, 0x0629, 0,
     7, 0xFE95, 0x062A, 0,
     6, 0xFE96, 0x062A, 0,
     4, 0xFE97, 0x062A, 0,
     5, 0xFE98, 0x062A, 0,
     7, 0xFE99, 0x062B, 0,
     6, 0xFE9A, 0x062B, 0,
     4, 0xFE9B, 0x062B, 0,
     5, 0xFE9C, 0x062B, 0,
     7, 0xFE9D, 0x062C, 0,
     6, 0xFE9E, 0x062C, 0,
     4, 0xFE9F, 0x062C, 0,
     5, 0xFEA0, 0x062C, 0,
     7, 0xFEA1, 0x062D, 0,
     6, 0xFEA2, 0x062D, 0,
     4, 0xFEA3, 0x062D, 0,
     5, 0xFEA4, 0x062D, 0,
     7, 0xFEA5, 0x062E, 0,
     6, 0xFEA6, 0x062E, 0,
     4, 0xFEA7, 0x062E, 0,
     5, 0xFEA8, 0x062E, 0,
     7, 0xFEA9, 0x062F, 0,
     6, 0xFEAA, 0x062F, 0,
     7, 0xFEAB, 0x0630, 0,
     6, 0xFEAC, 0x0630, 0,
     7, 0xFEAD, 0x0631, 0,
     6, 0xFEAE, 0x0631, 0,
     7, 0xFEAF, 0x0632, 0,
     6, 0xFEB0, 0x0632, 0,
     7, 0xFEB1, 0x0633, 0,
     6, 0xFEB2, 0x0633, 0,
     4, 0xFEB3, 0x0633, 0,
     5, 0xFEB4, 0x0633, 0,
     7, 0xFEB5, 0x0634, 0,
     6, 0xFEB6, 0x0634, 0,
     4, 0xFEB7, 0x0634, 0,
     5, 0xFEB8, 0x0634, 0,
     7, 0xFEB9, 0x0635, 0,
     6, 0xFEBA, 0x0635, 0,
     4, 0xFEBB, 0x0635, 0,
     5, 0xFEBC, 0x0635, 0,
     7, 0xFEBD, 0x0636, 0,
     6, 0xFEBE, 0x0636, 0,
     4, 0xFEBF, 0x0636, 0,
     5, 0xFEC0, 0x0636, 0,
     7, 0xFEC1, 0x0637, 0,
     6, 0xFEC2, 0x0637, 0,
     4, 0xFEC3, 0x0637, 0,
     5, 0xFEC4, 0x0637, 0,
     7, 0xFEC5, 0x0638, 0,
     6, 0xFEC6, 0x0638, 0,
     4, 0xFEC7, 0x0638, 0,
     5, 0xFEC8, 0x0638, 0,
     7, 0xFEC9, 0x0639, 0,
     6, 0xFECA, 0x0639, 0,
     4, 0xFECB, 0x0639, 0,
     5, 0xFECC, 0x0639, 0,
     7, 0xFECD, 0x063A, 0,
     6, 0xFECE, 0x063A, 0,
     4, 0xFECF, 0x063A, 0,
     5, 0xFED0, 0x063A, 0,
     7, 0xFED1, 0x0641, 0,
     6, 0xFED2, 0x0641, 0,
     4, 0xFED3, 0x0641, 0,
     5, 0xFED4, 0x0641, 0,
     7, 0xFED5, 0x0642, 0,
     6, 0xFED6, 0x0642, 0,
     4, 0xFED7, 0x0642, 0,
     5, 0xFED8, 0x0642, 0,
     7, 0xFED9, 0x0643, 0,
     6, 0xFEDA, 0x0643, 0,
     4, 0xFEDB, 0x0643, 0,
     5, 0xFEDC, 0x0643, 0,
     7, 0xFEDD, 0x0644, 0,
     6, 0xFEDE, 0x0644, 0,
     4, 0xFEDF, 0x0644, 0,
     5, 0xFEE0, 0x0644, 0,
     7, 0xFEE1, 0x0645, 0,
     6, 0xFEE2, 0x0645, 0,
     4, 0xFEE3, 0x0645, 0,
     5, 0xFEE4, 0x0645, 0,
     7, 0xFEE5, 0x0646, 0,
     6, 0xFEE6, 0x0646, 0,
     4, 0xFEE7, 0x0646, 0,
     5, 0xFEE8, 0x0646, 0,
     7, 0xFEE9, 0x0647, 0,
     6, 0xFEEA, 0x0647, 0,
     4, 0xFEEB, 0x0647, 0,
     5, 0xFEEC, 0x0647, 0,
     7, 0xFEED, 0x0648, 0,
     6, 0xFEEE, 0x0648, 0,
     7, 0xFEEF, 0x0649, 0,
     6, 0xFEF0, 0x0649, 0,
     7, 0xFEF1, 0x064A, 0,
     6, 0xFEF2, 0x064A, 0,
     4, 0xFEF3, 0x064A, 0,
     5, 0xFEF4, 0x064A, 0,
     7, 0xFEF5, 0x0644, 0x0622, 0,
     6, 0xFEF6, 0x0644, 0x0622, 0,
     7, 0xFEF7, 0x0644, 0x0623, 0,
     6, 0xFEF8, 0x0644, 0x0623, 0,
     7, 0xFEF9, 0x0644, 0x0625, 0,
     6, 0xFEFA, 0x0644, 0x0625, 0,
     7, 0xFEFB, 0x0644, 0x0627, 0,
     6, 0xFEFC, 0x0644, 0x0627, 0,
     12, 0xFF01, 0x0021, 0,
     12, 0xFF02, 0x0022, 0,
     12, 0xFF03, 0x0023, 0,
     12, 0xFF04, 0x0024, 0,
     12, 0xFF05, 0x0025, 0,
     12, 0xFF06, 0x0026, 0,
     12, 0xFF07, 0x0027, 0,
     12, 0xFF08, 0x0028, 0,
     12, 0xFF09, 0x0029, 0,
     12, 0xFF0A, 0x002A, 0,
     12, 0xFF0B, 0x002B, 0,
     12, 0xFF0C, 0x002C, 0,
     12, 0xFF0D, 0x002D, 0,
     12, 0xFF0E, 0x002E, 0,
     12, 0xFF0F, 0x002F, 0,
     12, 0xFF10, 0x0030, 0,
     12, 0xFF11, 0x0031, 0,
     12, 0xFF12, 0x0032, 0,
     12, 0xFF13, 0x0033, 0,
     12, 0xFF14, 0x0034, 0,
     12, 0xFF15, 0x0035, 0,
     12, 0xFF16, 0x0036, 0,
     12, 0xFF17, 0x0037, 0,
     12, 0xFF18, 0x0038, 0,
     12, 0xFF19, 0x0039, 0,
     12, 0xFF1A, 0x003A, 0,
     12, 0xFF1B, 0x003B, 0,
     12, 0xFF1C, 0x003C, 0,
     12, 0xFF1D, 0x003D, 0,
     12, 0xFF1E, 0x003E, 0,
     12, 0xFF1F, 0x003F, 0,
     12, 0xFF20, 0x0040, 0,
     12, 0xFF21, 0x0041, 0,
     12, 0xFF22, 0x0042, 0,
     12, 0xFF23, 0x0043, 0,
     12, 0xFF24, 0x0044, 0,
     12, 0xFF25, 0x0045, 0,
     12, 0xFF26, 0x0046, 0,
     12, 0xFF27, 0x0047, 0,
     12, 0xFF28, 0x0048, 0,
     12, 0xFF29, 0x0049, 0,
     12, 0xFF2A, 0x004A, 0,
     12, 0xFF2B, 0x004B, 0,
     12, 0xFF2C, 0x004C, 0,
     12, 0xFF2D, 0x004D, 0,
     12, 0xFF2E, 0x004E, 0,
     12, 0xFF2F, 0x004F, 0,
     12, 0xFF30, 0x0050, 0,
     12, 0xFF31, 0x0051, 0,
     12, 0xFF32, 0x0052, 0,
     12, 0xFF33, 0x0053, 0,
     12, 0xFF34, 0x0054, 0,
     12, 0xFF35, 0x0055, 0,
     12, 0xFF36, 0x0056, 0,
     12, 0xFF37, 0x0057, 0,
     12, 0xFF38, 0x0058, 0,
     12, 0xFF39, 0x0059, 0,
     12, 0xFF3A, 0x005A, 0,
     12, 0xFF3B, 0x005B, 0,
     12, 0xFF3C, 0x005C, 0,
     12, 0xFF3D, 0x005D, 0,
     12, 0xFF3E, 0x005E, 0,
     12, 0xFF3F, 0x005F, 0,
     12, 0xFF40, 0x0060, 0,
     12, 0xFF41, 0x0061, 0,
     12, 0xFF42, 0x0062, 0,
     12, 0xFF43, 0x0063, 0,
     12, 0xFF44, 0x0064, 0,
     12, 0xFF45, 0x0065, 0,
     12, 0xFF46, 0x0066, 0,
     12, 0xFF47, 0x0067, 0,
     12, 0xFF48, 0x0068, 0,
     12, 0xFF49, 0x0069, 0,
     12, 0xFF4A, 0x006A, 0,
     12, 0xFF4B, 0x006B, 0,
     12, 0xFF4C, 0x006C, 0,
     12, 0xFF4D, 0x006D, 0,
     12, 0xFF4E, 0x006E, 0,
     12, 0xFF4F, 0x006F, 0,
     12, 0xFF50, 0x0070, 0,
     12, 0xFF51, 0x0071, 0,
     12, 0xFF52, 0x0072, 0,
     12, 0xFF53, 0x0073, 0,
     12, 0xFF54, 0x0074, 0,
     12, 0xFF55, 0x0075, 0,
     12, 0xFF56, 0x0076, 0,
     12, 0xFF57, 0x0077, 0,
     12, 0xFF58, 0x0078, 0,
     12, 0xFF59, 0x0079, 0,
     12, 0xFF5A, 0x007A, 0,
     12, 0xFF5B, 0x007B, 0,
     12, 0xFF5C, 0x007C, 0,
     12, 0xFF5D, 0x007D, 0,
     12, 0xFF5E, 0x007E, 0,
     12, 0xFF5F, 0x2985, 0,
     12, 0xFF60, 0x2986, 0,
     13, 0xFF61, 0x3002, 0,
     13, 0xFF62, 0x300C, 0,
     13, 0xFF63, 0x300D, 0,
     13, 0xFF64, 0x3001, 0,
     13, 0xFF65, 0x30FB, 0,
     13, 0xFF66, 0x30F2, 0,
     13, 0xFF67, 0x30A1, 0,
     13, 0xFF68, 0x30A3, 0,
     13, 0xFF69, 0x30A5, 0,
     13, 0xFF6A, 0x30A7, 0,
     13, 0xFF6B, 0x30A9, 0,
     13, 0xFF6C, 0x30E3, 0,
     13, 0xFF6D, 0x30E5, 0,
     13, 0xFF6E, 0x30E7, 0,
     13, 0xFF6F, 0x30C3, 0,
     13, 0xFF70, 0x30FC, 0,
     13, 0xFF71, 0x30A2, 0,
     13, 0xFF72, 0x30A4, 0,
     13, 0xFF73, 0x30A6, 0,
     13, 0xFF74, 0x30A8, 0,
     13, 0xFF75, 0x30AA, 0,
     13, 0xFF76, 0x30AB, 0,
     13, 0xFF77, 0x30AD, 0,
     13, 0xFF78, 0x30AF, 0,
     13, 0xFF79, 0x30B1, 0,
     13, 0xFF7A, 0x30B3, 0,
     13, 0xFF7B, 0x30B5, 0,
     13, 0xFF7C, 0x30B7, 0,
     13, 0xFF7D, 0x30B9, 0,
     13, 0xFF7E, 0x30BB, 0,
     13, 0xFF7F, 0x30BD, 0,
     13, 0xFF80, 0x30BF, 0,
     13, 0xFF81, 0x30C1, 0,
     13, 0xFF82, 0x30C4, 0,
     13, 0xFF83, 0x30C6, 0,
     13, 0xFF84, 0x30C8, 0,
     13, 0xFF85, 0x30CA, 0,
     13, 0xFF86, 0x30CB, 0,
     13, 0xFF87, 0x30CC, 0,
     13, 0xFF88, 0x30CD, 0,
     13, 0xFF89, 0x30CE, 0,
     13, 0xFF8A, 0x30CF, 0,
     13, 0xFF8B, 0x30D2, 0,
     13, 0xFF8C, 0x30D5, 0,
     13, 0xFF8D, 0x30D8, 0,
     13, 0xFF8E, 0x30DB, 0,
     13, 0xFF8F, 0x30DE, 0,
     13, 0xFF90, 0x30DF, 0,
     13, 0xFF91, 0x30E0, 0,
     13, 0xFF92, 0x30E1, 0,
     13, 0xFF93, 0x30E2, 0,
     13, 0xFF94, 0x30E4, 0,
     13, 0xFF95, 0x30E6, 0,
     13, 0xFF96, 0x30E8, 0,
     13, 0xFF97, 0x30E9, 0,
     13, 0xFF98, 0x30EA, 0,
     13, 0xFF99, 0x30EB, 0,
     13, 0xFF9A, 0x30EC, 0,
     13, 0xFF9B, 0x30ED, 0,
     13, 0xFF9C, 0x30EF, 0,
     13, 0xFF9D, 0x30F3, 0,
     13, 0xFF9E, 0x3099, 0,
     13, 0xFF9F, 0x309A, 0,
     13, 0xFFA0, 0x3164, 0,
     13, 0xFFA1, 0x3131, 0,
     13, 0xFFA2, 0x3132, 0,
     13, 0xFFA3, 0x3133, 0,
     13, 0xFFA4, 0x3134, 0,
     13, 0xFFA5, 0x3135, 0,
     13, 0xFFA6, 0x3136, 0,
     13, 0xFFA7, 0x3137, 0,
     13, 0xFFA8, 0x3138, 0,
     13, 0xFFA9, 0x3139, 0,
     13, 0xFFAA, 0x313A, 0,
     13, 0xFFAB, 0x313B, 0,
     13, 0xFFAC, 0x313C, 0,
     13, 0xFFAD, 0x313D, 0,
     13, 0xFFAE, 0x313E, 0,
     13, 0xFFAF, 0x313F, 0,
     13, 0xFFB0, 0x3140, 0,
     13, 0xFFB1, 0x3141, 0,
     13, 0xFFB2, 0x3142, 0,
     13, 0xFFB3, 0x3143, 0,
     13, 0xFFB4, 0x3144, 0,
     13, 0xFFB5, 0x3145, 0,
     13, 0xFFB6, 0x3146, 0,
     13, 0xFFB7, 0x3147, 0,
     13, 0xFFB8, 0x3148, 0,
     13, 0xFFB9, 0x3149, 0,
     13, 0xFFBA, 0x314A, 0,
     13, 0xFFBB, 0x314B, 0,
     13, 0xFFBC, 0x314C, 0,
     13, 0xFFBD, 0x314D, 0,
     13, 0xFFBE, 0x314E, 0,
     13, 0xFFC2, 0x314F, 0,
     13, 0xFFC3, 0x3150, 0,
     13, 0xFFC4, 0x3151, 0,
     13, 0xFFC5, 0x3152, 0,
     13, 0xFFC6, 0x3153, 0,
     13, 0xFFC7, 0x3154, 0,
     13, 0xFFCA, 0x3155, 0,
     13, 0xFFCB, 0x3156, 0,
     13, 0xFFCC, 0x3157, 0,
     13, 0xFFCD, 0x3158, 0,
     13, 0xFFCE, 0x3159, 0,
     13, 0xFFCF, 0x315A, 0,
     13, 0xFFD2, 0x315B, 0,
     13, 0xFFD3, 0x315C, 0,
     13, 0xFFD4, 0x315D, 0,
     13, 0xFFD5, 0x315E, 0,
     13, 0xFFD6, 0x315F, 0,
     13, 0xFFD7, 0x3160, 0,
     13, 0xFFDA, 0x3161, 0,
     13, 0xFFDB, 0x3162, 0,
     13, 0xFFDC, 0x3163, 0,
     12, 0xFFE0, 0x00A2, 0,
     12, 0xFFE1, 0x00A3, 0,
     12, 0xFFE2, 0x00AC, 0,
     12, 0xFFE3, 0x00AF, 0,
     12, 0xFFE4, 0x00A6, 0,
     12, 0xFFE5, 0x00A5, 0,
     12, 0xFFE6, 0x20A9, 0,
     13, 0xFFE8, 0x2502, 0,
     13, 0xFFE9, 0x2190, 0,
     13, 0xFFEA, 0x2191, 0,
     13, 0xFFEB, 0x2192, 0,
     13, 0xFFEC, 0x2193, 0,
     13, 0xFFED, 0x25A0, 0,
     13, 0xFFEE, 0x25CB, 0,
 
 };
 
 static const Q_UINT16 di_00[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1, 0, 0, 0, 0, 0, 0, 0,
     5, 0, 10, 0, 0, 0, 0, 14,
     0, 0, 19, 23, 27, 32, 0, 0,
     36, 41, 45, 0, 49, 55, 61, 0,
     67, 72, 77, 82, 87, 92, 0, 97,
     102, 107, 112, 117, 122, 127, 132, 137,
     0, 142, 147, 152, 157, 162, 167, 0,
     0, 172, 177, 182, 187, 192, 0, 0,
     197, 202, 207, 212, 217, 222, 0, 227,
     232, 237, 242, 247, 252, 257, 262, 267,
     0, 272, 277, 282, 287, 292, 297, 0,
     0, 302, 307, 312, 317, 322, 0, 327,
 };
 
 static const Q_UINT16 di_01[] = {
     332, 337, 342, 347, 352, 357, 362, 367,
     372, 377, 382, 387, 392, 397, 402, 407,
     0, 0, 412, 417, 422, 427, 432, 437,
     442, 447, 452, 457, 462, 467, 472, 477,
     482, 487, 492, 497, 502, 507, 0, 0,
     512, 517, 522, 527, 532, 537, 542, 547,
     552, 0, 557, 562, 567, 572, 577, 582,
     0, 587, 592, 597, 602, 607, 612, 617,
     622, 0, 0, 627, 632, 637, 642, 647,
     652, 657, 0, 0, 662, 667, 672, 677,
     682, 687, 0, 0, 692, 697, 702, 707,
     712, 717, 722, 727, 732, 737, 742, 747,
     752, 757, 762, 767, 772, 777, 0, 0,
     782, 787, 792, 797, 802, 807, 812, 817,
     822, 827, 832, 837, 842, 847, 852, 857,
     862, 867, 872, 877, 882, 887, 892, 897,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     901, 906, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 911,
     916, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 921, 926, 931, 936,
     941, 946, 951, 956, 961, 966, 971, 976,
     981, 986, 991, 996, 1001, 1006, 1011, 1016,
     1021, 1026, 1031, 1036, 1041, 0, 1046, 1051,
     1056, 1061, 1066, 1071, 0, 0, 1076, 1081,
     1086, 1091, 1096, 1101, 1106, 1111, 1116, 1121,
     1126, 1131, 1136, 1141, 1146, 1151, 0, 0,
     1156, 1161, 1166, 1171, 1176, 1181, 1186, 1191,
 };
 
 static const Q_UINT16 di_02[] = {
     1196, 1201, 1206, 1211, 1216, 1221, 1226, 1231,
     1236, 1241, 1246, 1251, 1256, 1261, 1266, 1271,
     1276, 1281, 1286, 1291, 1296, 1301, 1306, 1311,
     1316, 1321, 1326, 1331, 0, 0, 1336, 1341,
     0, 0, 0, 0, 0, 0, 1346, 1351,
     1356, 1361, 1366, 1371, 1376, 1381, 1386, 1391,
     1396, 1401, 1406, 1411, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1416, 1420, 1424, 1428, 1432, 1436, 1440, 1444,
     1448, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1452, 1457, 1462, 1467, 1472, 1477, 0, 0,
     1482, 1486, 1490, 1494, 1498, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_03[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1502, 1506, 0, 1510, 1514, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 1519, 0, 0, 0,
     0, 0, 1523, 0, 0, 0, 1528, 0,
     0, 0, 0, 0, 1532, 1537, 1542, 1547,
     1551, 1556, 1561, 0, 1566, 0, 1571, 1576,
     1581, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 1586, 1591, 1596, 1601, 1606, 1611,
     1616, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 1621, 1626, 1631, 1636, 1641, 0,
     1646, 1650, 1654, 1658, 1663, 1668, 1672, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1676, 1680, 1684, 0, 1688, 1692, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_04[] = {
     1696, 1701, 0, 1706, 0, 0, 0, 1711,
     0, 0, 0, 0, 1716, 1721, 1726, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 1731, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 1736, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1741, 1746, 0, 1751, 0, 0, 0, 1756,
     0, 0, 0, 0, 1761, 1766, 1771, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 1776, 1781,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 1786, 1791, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1796, 1801, 1806, 1811, 0, 0, 1816, 1821,
     0, 0, 1826, 1831, 1836, 1841, 1846, 1851,
     0, 0, 1856, 1861, 1866, 1871, 1876, 1881,
     0, 0, 1886, 1891, 1896, 1901, 1906, 1911,
     1916, 1921, 1926, 1931, 1936, 1941, 0, 0,
     1946, 1951, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_05[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 1956,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_06[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 1961, 1966, 1971, 1976, 1981, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 1986, 1991, 1996,
     2001, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     2006, 0, 2011, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 2016, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_07[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_09[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 2021, 0, 0, 0, 0, 0, 0,
     0, 2026, 0, 0, 2031, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     2036, 2041, 2046, 2051, 2056, 2061, 2066, 2071,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 2076, 2081, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 2086, 2091, 0, 2096,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_0A[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 2101, 0, 0, 2106, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 2111, 2116, 2121, 0, 0, 2126, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_0B[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     2131, 0, 0, 2136, 2141, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 2146, 2151, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 2156, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 2161, 2166, 2171, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_0C[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     2176, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     2181, 0, 0, 0, 0, 0, 0, 2186,
     2191, 0, 2196, 2201, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_0D[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 2206, 2211, 2216, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 2221, 0, 2226, 2231, 2236, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_0E[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 2241, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 2246, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 2251, 2256, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_0F[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 2261, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 2265, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 2270, 0, 0,
     0, 0, 2275, 0, 0, 0, 0, 2280,
     0, 0, 0, 0, 2285, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 2290, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 2295, 0, 2300, 2305, 2310,
     2315, 2320, 0, 0, 0, 0, 0, 0,
     0, 2325, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 2330, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 2335, 0, 0,
     0, 0, 2340, 0, 0, 0, 0, 2345,
     0, 0, 0, 0, 2350, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 2355, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_10[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 2360, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_1E[] = {
     2365, 2370, 2375, 2380, 2385, 2390, 2395, 2400,
     2405, 2410, 2415, 2420, 2425, 2430, 2435, 2440,
     2445, 2450, 2455, 2460, 2465, 2470, 2475, 2480,
     2485, 2490, 2495, 2500, 2505, 2510, 2515, 2520,
     2525, 2530, 2535, 2540, 2545, 2550, 2555, 2560,
     2565, 2570, 2575, 2580, 2585, 2590, 2595, 2600,
     2605, 2610, 2615, 2620, 2625, 2630, 2635, 2640,
     2645, 2650, 2655, 2660, 2665, 2670, 2675, 2680,
     2685, 2690, 2695, 2700, 2705, 2710, 2715, 2720,
     2725, 2730, 2735, 2740, 2745, 2750, 2755, 2760,
     2765, 2770, 2775, 2780, 2785, 2790, 2795, 2800,
     2805, 2810, 2815, 2820, 2825, 2830, 2835, 2840,
     2845, 2850, 2855, 2860, 2865, 2870, 2875, 2880,
     2885, 2890, 2895, 2900, 2905, 2910, 2915, 2920,
     2925, 2930, 2935, 2940, 2945, 2950, 2955, 2960,
     2965, 2970, 2975, 2980, 2985, 2990, 2995, 3000,
     3005, 3010, 3015, 3020, 3025, 3030, 3035, 3040,
     3045, 3050, 3055, 3060, 3065, 3070, 3075, 3080,
     3085, 3090, 3095, 3100, 3105, 3110, 3115, 3120,
     3125, 3130, 3135, 3140, 0, 0, 0, 0,
     3145, 3150, 3155, 3160, 3165, 3170, 3175, 3180,
     3185, 3190, 3195, 3200, 3205, 3210, 3215, 3220,
     3225, 3230, 3235, 3240, 3245, 3250, 3255, 3260,
     3265, 3270, 3275, 3280, 3285, 3290, 3295, 3300,
     3305, 3310, 3315, 3320, 3325, 3330, 3335, 3340,
     3345, 3350, 3355, 3360, 3365, 3370, 3375, 3380,
     3385, 3390, 3395, 3400, 3405, 3410, 3415, 3420,
     3425, 3430, 3435, 3440, 3445, 3450, 3455, 3460,
     3465, 3470, 3475, 3480, 3485, 3490, 3495, 3500,
     3505, 3510, 3515, 3520, 3525, 3530, 3535, 3540,
     3545, 3550, 3555, 3560, 3565, 3570, 3575, 3580,
     3585, 3590, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_1F[] = {
     3595, 3600, 3605, 3610, 3615, 3620, 3625, 3630,
     3635, 3640, 3645, 3650, 3655, 3660, 3665, 3670,
     3675, 3680, 3685, 3690, 3695, 3700, 0, 0,
     3705, 3710, 3715, 3720, 3725, 3730, 0, 0,
     3735, 3740, 3745, 3750, 3755, 3760, 3765, 3770,
     3775, 3780, 3785, 3790, 3795, 3800, 3805, 3810,
     3815, 3820, 3825, 3830, 3835, 3840, 3845, 3850,
     3855, 3860, 3865, 3870, 3875, 3880, 3885, 3890,
     3895, 3900, 3905, 3910, 3915, 3920, 0, 0,
     3925, 3930, 3935, 3940, 3945, 3950, 0, 0,
     3955, 3960, 3965, 3970, 3975, 3980, 3985, 3990,
     0, 3995, 0, 4000, 0, 4005, 0, 4010,
     4015, 4020, 4025, 4030, 4035, 4040, 4045, 4050,
     4055, 4060, 4065, 4070, 4075, 4080, 4085, 4090,
     4095, 4100, 4104, 4109, 4113, 4118, 4122, 4127,
     4131, 4136, 4140, 4145, 4149, 4154, 0, 0,
     4158, 4163, 4168, 4173, 4178, 4183, 4188, 4193,
     4198, 4203, 4208, 4213, 4218, 4223, 4228, 4233,
     4238, 4243, 4248, 4253, 4258, 4263, 4268, 4273,
     4278, 4283, 4288, 4293, 4298, 4303, 4308, 4313,
     4318, 4323, 4328, 4333, 4338, 4343, 4348, 4353,
     4358, 4363, 4368, 4373, 4378, 4383, 4388, 4393,
     4398, 4403, 4408, 4413, 4418, 0, 4423, 4428,
     4433, 4438, 4443, 4448, 4452, 4457, 4462, 4466,
     4471, 4476, 4481, 4486, 4491, 0, 4496, 4501,
     4506, 4511, 4515, 4520, 4524, 4529, 4534, 4539,
     4544, 4549, 4554, 4559, 0, 0, 4563, 4568,
     4573, 4578, 4583, 4588, 0, 4592, 4597, 4602,
     4607, 4612, 4617, 4622, 4626, 4631, 4636, 4641,
     4646, 4651, 4656, 4661, 4665, 4670, 4675, 4679,
     0, 0, 4683, 4688, 4693, 0, 4698, 4703,
     4708, 4713, 4717, 4722, 4726, 4731, 4735, 0,
 };
 
 static const Q_UINT16 di_20[] = {
     4740, 4744, 4748, 4752, 4756, 4760, 4764, 4768,
     4772, 4776, 4780, 0, 0, 0, 0, 0,
     0, 4784, 0, 0, 0, 0, 0, 4788,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 4793, 4797, 4802, 0,
     0, 0, 0, 0, 0, 0, 0, 4808,
     0, 0, 0, 4812, 4817, 0, 4823, 4828,
     0, 0, 0, 0, 4834, 0, 4839, 0,
     0, 0, 0, 0, 0, 0, 0, 4844,
     4849, 4854, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 4859,
     0, 0, 0, 0, 0, 0, 0, 4866,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     4870, 4874, 0, 0, 4878, 4882, 4886, 4890,
     4894, 4898, 4902, 4906, 4910, 4914, 4918, 4922,
     4926, 4930, 4934, 4938, 4942, 4946, 4950, 4954,
     4958, 4962, 4966, 4970, 4974, 4978, 4982, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     4986, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_21[] = {
     4991, 4997, 5003, 5007, 0, 5012, 5018, 5024,
     0, 5028, 5033, 5037, 5041, 5045, 5049, 5053,
     5057, 5061, 5065, 5069, 0, 5073, 5077, 0,
     0, 5082, 5086, 5090, 5094, 5098, 0, 0,
     5102, 5107, 5113, 0, 5118, 0, 5122, 0,
     5126, 0, 5130, 5134, 5138, 5142, 0, 5146,
     5150, 5154, 0, 5158, 5162, 5166, 5170, 5174,
     5178, 5182, 0, 0, 0, 5186, 5190, 5194,
     5198, 0, 0, 0, 0, 5202, 5206, 5210,
     5214, 5218, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 5222, 5228, 5234, 5240, 5246,
     5252, 5258, 5264, 5270, 5276, 5282, 5288, 5294,
     5299, 5303, 5308, 5314, 5319, 5323, 5328, 5334,
     5341, 5346, 5350, 5355, 5361, 5365, 5369, 5373,
     5377, 5381, 5386, 5392, 5397, 5401, 5406, 5412,
     5419, 5424, 5428, 5433, 5439, 5443, 5447, 5451,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 5455, 5460, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 5465, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 5470, 5475, 5480,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_22[] = {
     0, 0, 0, 0, 5485, 0, 0, 0,
     0, 5490, 0, 0, 5495, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 5500, 0, 5505, 0,
     0, 0, 0, 0, 5510, 5515, 0, 5521,
     5526, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 5532, 0, 0, 5537, 0, 0, 5542,
     0, 5547, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     5552, 0, 5557, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 5562, 5567, 5572,
     5577, 5582, 0, 0, 5587, 5592, 0, 0,
     5597, 5602, 0, 0, 0, 0, 0, 0,
     5607, 5612, 0, 0, 5617, 5622, 0, 0,
     5627, 5632, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 5637, 5642, 5647, 5652,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     5657, 5662, 5667, 5672, 0, 0, 0, 0,
     0, 0, 5677, 5682, 5687, 5692, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_23[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 5697, 5701, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_24[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     5705, 5709, 5713, 5717, 5721, 5725, 5729, 5733,
     5737, 5741, 5746, 5751, 5756, 5761, 5766, 5771,
     5776, 5781, 5786, 5791, 5796, 5802, 5808, 5814,
     5820, 5826, 5832, 5838, 5844, 5850, 5857, 5864,
     5871, 5878, 5885, 5892, 5899, 5906, 5913, 5920,
     5927, 5932, 5937, 5942, 5947, 5952, 5957, 5962,
     5967, 5972, 5978, 5984, 5990, 5996, 6002, 6008,
     6014, 6020, 6026, 6032, 6038, 6044, 6050, 6056,
     6062, 6068, 6074, 6080, 6086, 6092, 6098, 6104,
     6110, 6116, 6122, 6128, 6134, 6140, 6146, 6152,
     6158, 6164, 6170, 6176, 6182, 6188, 6194, 6198,
     6202, 6206, 6210, 6214, 6218, 6222, 6226, 6230,
     6234, 6238, 6242, 6246, 6250, 6254, 6258, 6262,
     6266, 6270, 6274, 6278, 6282, 6286, 6290, 6294,
     6298, 6302, 6306, 6310, 6314, 6318, 6322, 6326,
     6330, 6334, 6338, 6342, 6346, 6350, 6354, 6358,
     6362, 6366, 6370, 6374, 6378, 6382, 6386, 6390,
     6394, 6398, 6402, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_2A[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 6406, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 6413, 6419, 6424, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 6430, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_2E[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 6435,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 6439, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_2F[] = {
     6443, 6447, 6451, 6455, 6459, 6463, 6467, 6471,
     6475, 6479, 6483, 6487, 6491, 6495, 6499, 6503,
     6507, 6511, 6515, 6519, 6523, 6527, 6531, 6535,
     6539, 6543, 6547, 6551, 6555, 6559, 6563, 6567,
     6571, 6575, 6579, 6583, 6587, 6591, 6595, 6599,
     6603, 6607, 6611, 6615, 6619, 6623, 6627, 6631,
     6635, 6639, 6643, 6647, 6651, 6655, 6659, 6663,
     6667, 6671, 6675, 6679, 6683, 6687, 6691, 6695,
     6699, 6703, 6707, 6711, 6715, 6719, 6723, 6727,
     6731, 6735, 6739, 6743, 6747, 6751, 6755, 6759,
     6763, 6767, 6771, 6775, 6779, 6783, 6787, 6791,
     6795, 6799, 6803, 6807, 6811, 6815, 6819, 6823,
     6827, 6831, 6835, 6839, 6843, 6847, 6851, 6855,
     6859, 6863, 6867, 6871, 6875, 6879, 6883, 6887,
     6891, 6895, 6899, 6903, 6907, 6911, 6915, 6919,
     6923, 6927, 6931, 6935, 6939, 6943, 6947, 6951,
     6955, 6959, 6963, 6967, 6971, 6975, 6979, 6983,
     6987, 6991, 6995, 6999, 7003, 7007, 7011, 7015,
     7019, 7023, 7027, 7031, 7035, 7039, 7043, 7047,
     7051, 7055, 7059, 7063, 7067, 7071, 7075, 7079,
     7083, 7087, 7091, 7095, 7099, 7103, 7107, 7111,
     7115, 7119, 7123, 7127, 7131, 7135, 7139, 7143,
     7147, 7151, 7155, 7159, 7163, 7167, 7171, 7175,
     7179, 7183, 7187, 7191, 7195, 7199, 7203, 7207,
     7211, 7215, 7219, 7223, 7227, 7231, 7235, 7239,
     7243, 7247, 7251, 7255, 7259, 7263, 7267, 7271,
     7275, 7279, 7283, 7287, 7291, 7295, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_30[] = {
     7299, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 7303, 0,
     7307, 7311, 7315, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 7319, 0, 7324, 0,
     7329, 0, 7334, 0, 7339, 0, 7344, 0,
     7349, 0, 7354, 0, 7359, 0, 7364, 0,
     7369, 0, 7374, 0, 0, 7379, 0, 7384,
     0, 7389, 0, 0, 0, 0, 0, 0,
     7394, 7399, 0, 7404, 7409, 0, 7414, 7419,
     0, 7424, 7429, 0, 7434, 7439, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 7444, 0, 0, 0,
     0, 0, 0, 7449, 7454, 0, 7459, 7464,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 7469, 0, 7474, 0,
     7479, 0, 7484, 0, 7489, 0, 7494, 0,
     7499, 0, 7504, 0, 7509, 0, 7514, 0,
     7519, 0, 7524, 0, 0, 7529, 0, 7534,
     0, 7539, 0, 0, 0, 0, 0, 0,
     7544, 7549, 0, 7554, 7559, 0, 7564, 7569,
     0, 7574, 7579, 0, 7584, 7589, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 7594, 0, 0, 7599,
     7604, 7609, 7614, 0, 0, 0, 7619, 7624,
 };
 
 static const Q_UINT16 di_31[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 7629, 7633, 7637, 7641, 7645, 7649, 7653,
     7657, 7661, 7665, 7669, 7673, 7677, 7681, 7685,
     7689, 7693, 7697, 7701, 7705, 7709, 7713, 7717,
     7721, 7725, 7729, 7733, 7737, 7741, 7745, 7749,
     7753, 7757, 7761, 7765, 7769, 7773, 7777, 7781,
     7785, 7789, 7793, 7797, 7801, 7805, 7809, 7813,
     7817, 7821, 7825, 7829, 7833, 7837, 7841, 7845,
     7849, 7853, 7857, 7861, 7865, 7869, 7873, 7877,
     7881, 7885, 7889, 7893, 7897, 7901, 7905, 7909,
     7913, 7917, 7921, 7925, 7929, 7933, 7937, 7941,
     7945, 7949, 7953, 7957, 7961, 7965, 7969, 7973,
     7977, 7981, 7985, 7989, 7993, 7997, 8001, 0,
     0, 0, 8005, 8009, 8013, 8017, 8021, 8025,
     8029, 8033, 8037, 8041, 8045, 8049, 8053, 8057,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_32[] = {
     8061, 8067, 8073, 8079, 8085, 8091, 8097, 8103,
     8109, 8115, 8121, 8127, 8133, 8139, 8145, 8152,
     8159, 8166, 8173, 8180, 8187, 8194, 8201, 8208,
     8215, 8222, 8229, 8236, 8243, 0, 0, 0,
     8250, 8256, 8262, 8268, 8274, 8280, 8286, 8292,
     8298, 8304, 8310, 8316, 8322, 8328, 8334, 8340,
     8346, 8352, 8358, 8364, 8370, 8376, 8382, 8388,
     8394, 8400, 8406, 8412, 8418, 8424, 8430, 8436,
     8442, 8448, 8454, 8460, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 8466, 8471, 8476, 8481, 8486, 8491, 8496,
     8501, 8506, 8511, 8516, 8521, 8526, 8531, 8536,
     8541, 8545, 8549, 8553, 8557, 8561, 8565, 8569,
     8573, 8577, 8581, 8585, 8589, 8593, 8597, 8602,
     8607, 8612, 8617, 8622, 8627, 8632, 8637, 8642,
     8647, 8652, 8657, 8662, 0, 0, 0, 0,
     8667, 8671, 8675, 8679, 8683, 8687, 8691, 8695,
     8699, 8703, 8707, 8711, 8715, 8719, 8723, 8727,
     8731, 8735, 8739, 8743, 8747, 8751, 8755, 8759,
     8763, 8767, 8771, 8775, 8779, 8783, 8787, 8791,
     8795, 8799, 8803, 8807, 8811, 8815, 8819, 8823,
     8827, 8831, 8835, 8839, 8843, 8847, 8851, 8855,
     8859, 8863, 8868, 8873, 8878, 8883, 8888, 8893,
     8898, 8903, 8908, 8913, 8918, 8923, 8928, 8933,
     8938, 8943, 8948, 8953, 8958, 8963, 8968, 8973,
     8978, 8983, 8989, 8995, 0, 0, 0, 0,
     9001, 9005, 9009, 9013, 9017, 9021, 9025, 9029,
     9033, 9037, 9041, 9045, 9049, 9053, 9057, 9061,
     9065, 9069, 9073, 9077, 9081, 9085, 9089, 9093,
     9097, 9101, 9105, 9109, 9113, 9117, 9121, 9125,
     9129, 9133, 9137, 9141, 9145, 9149, 9153, 9157,
     9161, 9165, 9169, 9173, 9177, 9181, 9185, 0,
 };
 
 static const Q_UINT16 di_33[] = {
     9189, 9196, 9203, 9210, 9216, 9223, 9229, 9235,
     9243, 9250, 9256, 9262, 9268, 9275, 9282, 9288,
     9294, 9299, 9305, 9312, 9319, 9324, 9332, 9341,
     9349, 9355, 9363, 9371, 9378, 9384, 9390, 9396,
     9403, 9411, 9418, 9424, 9430, 9436, 9441, 9446,
     9451, 9456, 9462, 9468, 9476, 9482, 9489, 9497,
     9503, 9508, 9513, 9521, 9528, 9536, 9542, 9550,
     9555, 9561, 9567, 9573, 9579, 9585, 9592, 9598,
     9603, 9609, 9615, 9621, 9628, 9634, 9640, 9646,
     9654, 9661, 9666, 9674, 9679, 9686, 9693, 9699,
     9705, 9711, 9718, 9723, 9729, 9736, 9741, 9749,
     9755, 9760, 9765, 9770, 9775, 9780, 9785, 9790,
     9795, 9800, 9805, 9811, 9817, 9823, 9829, 9835,
     9841, 9847, 9853, 9859, 9865, 9871, 9877, 9883,
     9889, 9895, 9901, 9906, 9911, 9917, 9922, 0,
     0, 0, 0, 9927, 9932, 9937, 9942, 9947,
     9954, 9959, 9964, 9969, 9974, 9979, 9984, 9989,
     9994, 10000, 10007, 10012, 10017, 10022, 10027, 10032,
     10037, 10042, 10048, 10054, 10060, 10066, 10071, 10076,
     10081, 10086, 10091, 10096, 10101, 10106, 10111, 10116,
     10122, 10128, 10133, 10139, 10145, 10151, 10156, 10162,
     10168, 10175, 10180, 10186, 10192, 10198, 10204, 10212,
     10221, 10226, 10231, 10236, 10241, 10246, 10251, 10256,
     10261, 10266, 10271, 10276, 10281, 10286, 10291, 10296,
     10301, 10306, 10311, 10318, 10323, 10328, 10333, 10340,
     10346, 10351, 10356, 10361, 10366, 10371, 10376, 10381,
     10386, 10391, 10396, 10402, 10407, 10412, 10418, 10424,
     10429, 10436, 10442, 10447, 10452, 10457, 0, 0,
     10462, 10467, 10472, 10477, 10482, 10487, 10492, 10497,
     10502, 10507, 10513, 10519, 10525, 10531, 10537, 10543,
     10549, 10555, 10561, 10567, 10573, 10579, 10585, 10591,
     10597, 10603, 10609, 10615, 10621, 10627, 10633, 0,
 };
 
 static const Q_UINT16 di_F9[] = {
     10639, 10643, 10647, 10651, 10655, 10659, 10663, 10667,
     10671, 10675, 10679, 10683, 10687, 10691, 10695, 10699,
     10703, 10707, 10711, 10715, 10719, 10723, 10727, 10731,
     10735, 10739, 10743, 10747, 10751, 10755, 10759, 10763,
     10767, 10771, 10775, 10779, 10783, 10787, 10791, 10795,
     10799, 10803, 10807, 10811, 10815, 10819, 10823, 10827,
     10831, 10835, 10839, 10843, 10847, 10851, 10855, 10859,
     10863, 10867, 10871, 10875, 10879, 10883, 10887, 10891,
     10895, 10899, 10903, 10907, 10911, 10915, 10919, 10923,
     10927, 10931, 10935, 10939, 10943, 10947, 10951, 10955,
     10959, 10963, 10967, 10971, 10975, 10979, 10983, 10987,
     10991, 10995, 10999, 11003, 11007, 11011, 11015, 11019,
     11023, 11027, 11031, 11035, 11039, 11043, 11047, 11051,
     11055, 11059, 11063, 11067, 11071, 11075, 11079, 11083,
     11087, 11091, 11095, 11099, 11103, 11107, 11111, 11115,
     11119, 11123, 11127, 11131, 11135, 11139, 11143, 11147,
     11151, 11155, 11159, 11163, 11167, 11171, 11175, 11179,
     11183, 11187, 11191, 11195, 11199, 11203, 11207, 11211,
     11215, 11219, 11223, 11227, 11231, 11235, 11239, 11243,
     11247, 11251, 11255, 11259, 11263, 11267, 11271, 11275,
     11279, 11283, 11287, 11291, 11295, 11299, 11303, 11307,
     11311, 11315, 11319, 11323, 11327, 11331, 11335, 11339,
     11343, 11347, 11351, 11355, 11359, 11363, 11367, 11371,
     11375, 11379, 11383, 11387, 11391, 11395, 11399, 11403,
     11407, 11411, 11415, 11419, 11423, 11427, 11431, 11435,
     11439, 11443, 11447, 11451, 11455, 11459, 11463, 11467,
     11471, 11475, 11479, 11483, 11487, 11491, 11495, 11499,
     11503, 11507, 11511, 11515, 11519, 11523, 11527, 11531,
     11535, 11539, 11543, 11547, 11551, 11555, 11559, 11563,
     11567, 11571, 11575, 11579, 11583, 11587, 11591, 11595,
     11599, 11603, 11607, 11611, 11615, 11619, 11623, 11627,
     11631, 11635, 11639, 11643, 11647, 11651, 11655, 11659,
 };
 
 static const Q_UINT16 di_FA[] = {
     11663, 11667, 11671, 11675, 11679, 11683, 11687, 11691,
     11695, 11699, 11703, 11707, 11711, 11715, 0, 0,
     11719, 0, 11723, 0, 0, 11727, 11731, 11735,
     11739, 11743, 11747, 11751, 11755, 11759, 11763, 0,
     11767, 0, 11771, 0, 0, 11775, 11779, 0,
     0, 0, 11783, 11787, 11791, 11795, 0, 0,
     11799, 11803, 11807, 11811, 11815, 11819, 11823, 11827,
     11831, 11835, 11839, 11843, 11847, 11851, 11855, 11859,
     11863, 11867, 11871, 11875, 11879, 11883, 11887, 11891,
     11895, 11899, 11903, 11907, 11911, 11915, 11919, 11923,
     11927, 11931, 11935, 11939, 11943, 11947, 11951, 11955,
     11959, 11963, 11967, 11971, 11975, 11979, 11983, 11987,
     11991, 11995, 11999, 12003, 12007, 12011, 12015, 12019,
     12023, 12027, 12031, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 di_FB[] = {
     12035, 12040, 12045, 12050, 12056, 12062, 12067, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 12072, 12077, 12082, 12087, 12092,
     0, 0, 0, 0, 0, 12097, 0, 12102,
     12107, 12111, 12115, 12119, 12123, 12127, 12131, 12135,
     12139, 12143, 12147, 12152, 12157, 12162, 12167, 12172,
     12177, 12182, 12187, 12192, 12197, 12202, 12207, 0,
     12212, 12217, 12222, 12227, 12232, 0, 12237, 0,
     12242, 12247, 0, 12252, 12257, 0, 12262, 12267,
     12272, 12277, 12282, 12287, 12292, 12297, 12302, 12307,
     12312, 12316, 12320, 12324, 12328, 12332, 12336, 12340,
     12344, 12348, 12352, 12356, 12360, 12364, 12368, 12372,
     12376, 12380, 12384, 12388, 12392, 12396, 12400, 12404,
     12408, 12412, 12416, 12420, 12424, 12428, 12432, 12436,
     12440, 12444, 12448, 12452, 12456, 12460, 12464, 12468,
     12472, 12476, 12480, 12484, 12488, 12492, 12496, 12500,
     12504, 12508, 12512, 12516, 12520, 12524, 12528, 12532,
     12536, 12540, 12544, 12548, 12552, 12556, 12560, 12564,
     12568, 12572, 12576, 12580, 12584, 12588, 12592, 12596,
     12600, 12604, 12608, 12612, 12616, 12620, 12624, 12628,
     12632, 12636, 12640, 12644, 12648, 12652, 12656, 12660,
     12664, 12668, 12672, 12676, 12680, 12684, 12688, 12692,
     12696, 12700, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 12704, 12708, 12712, 12716, 12720,
     12724, 12728, 12732, 12736, 12740, 12744, 12748, 12752,
     12756, 12760, 12764, 12768, 12772, 12776, 12780, 12784,
     12788, 12792, 12796, 12801, 12806, 12811, 12816, 12821,
     12826, 12831, 12836, 12841, 12846, 12851, 12856, 12861,
     12866, 12871, 12876, 12881, 12886, 12890, 12894, 12898,
 };
 
 static const Q_UINT16 di_FC[] = {
     12902, 12907, 12912, 12917, 12922, 12927, 12932, 12937,
     12942, 12947, 12952, 12957, 12962, 12967, 12972, 12977,
     12982, 12987, 12992, 12997, 13002, 13007, 13012, 13017,
     13022, 13027, 13032, 13037, 13042, 13047, 13052, 13057,
     13062, 13067, 13072, 13077, 13082, 13087, 13092, 13097,
     13102, 13107, 13112, 13117, 13122, 13127, 13132, 13137,
     13142, 13147, 13152, 13157, 13162, 13167, 13172, 13177,
     13182, 13187, 13192, 13197, 13202, 13207, 13212, 13217,
     13222, 13227, 13232, 13237, 13242, 13247, 13252, 13257,
     13262, 13267, 13272, 13277, 13282, 13287, 13292, 13297,
     13302, 13307, 13312, 13317, 13322, 13327, 13332, 13337,
     13342, 13347, 13352, 13357, 13362, 13367, 13372, 13378,
     13384, 13390, 13396, 13402, 13408, 13413, 13418, 13423,
     13428, 13433, 13438, 13443, 13448, 13453, 13458, 13463,
     13468, 13473, 13478, 13483, 13488, 13493, 13498, 13503,
     13508, 13513, 13518, 13523, 13528, 13533, 13538, 13543,
     13548, 13553, 13558, 13563, 13568, 13573, 13578, 13583,
     13588, 13593, 13598, 13603, 13608, 13613, 13618, 13623,
     13628, 13633, 13638, 13643, 13648, 13653, 13658, 13663,
     13668, 13673, 13678, 13683, 13688, 13693, 13698, 13703,
     13708, 13713, 13718, 13723, 13728, 13733, 13738, 13743,
     13748, 13753, 13758, 13763, 13768, 13773, 13778, 13783,
     13788, 13793, 13798, 13803, 13808, 13813, 13818, 13823,
     13828, 13833, 13838, 13843, 13848, 13853, 13858, 13863,
     13868, 13873, 13878, 13883, 13888, 13893, 13898, 13903,
     13908, 13913, 13918, 13923, 13928, 13933, 13938, 13943,
     13948, 13953, 13958, 13963, 13968, 13973, 13978, 13983,
     13988, 13993, 13998, 14003, 14008, 14013, 14018, 14023,
     14028, 14033, 14038, 14043, 14048, 14053, 14058, 14063,
     14068, 14073, 14078, 14083, 14088, 14093, 14098, 14103,
     14108, 14113, 14118, 14124, 14130, 14136, 14141, 14146,
     14151, 14156, 14161, 14166, 14171, 14176, 14181, 14186,
 };
 
 static const Q_UINT16 di_FD[] = {
     14191, 14196, 14201, 14206, 14211, 14216, 14221, 14226,
     14231, 14236, 14241, 14246, 14251, 14256, 14261, 14266,
     14271, 14276, 14281, 14286, 14291, 14296, 14301, 14306,
     14311, 14316, 14321, 14326, 14331, 14336, 14341, 14346,
     14351, 14356, 14361, 14366, 14371, 14376, 14381, 14386,
     14391, 14396, 14401, 14406, 14411, 14416, 14421, 14426,
     14431, 14436, 14441, 14446, 14451, 14456, 14461, 14466,
     14471, 14476, 14481, 14486, 14491, 14496, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     14501, 14507, 14513, 14519, 14525, 14531, 14537, 14543,
     14549, 14555, 14561, 14567, 14573, 14579, 14585, 14591,
     14597, 14603, 14609, 14615, 14621, 14627, 14633, 14639,
     14645, 14651, 14657, 14663, 14669, 14675, 14681, 14687,
     14693, 14699, 14705, 14711, 14717, 14723, 14729, 14735,
     14741, 14747, 14753, 14759, 14765, 14771, 14777, 14783,
     14789, 14795, 14801, 14807, 14813, 14819, 14825, 14831,
     14837, 14843, 14849, 14855, 14861, 14867, 14873, 14879,
     0, 0, 14885, 14891, 14897, 14903, 14909, 14915,
     14921, 14927, 14933, 14939, 14945, 14951, 14957, 14963,
     14969, 14975, 14981, 14987, 14993, 14999, 15005, 15011,
     15017, 15023, 15029, 15035, 15041, 15047, 15053, 15059,
     15065, 15071, 15077, 15083, 15089, 15095, 15101, 15107,
     15113, 15119, 15125, 15131, 15137, 15143, 15149, 15155,
     15161, 15167, 15173, 15179, 15185, 15191, 15197, 15203,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     15209, 15215, 15221, 15228, 15235, 15242, 15249, 15256,
     15263, 15270, 15276, 15297, 15308, 0, 0, 0,
 };
 
 static const Q_UINT16 di_FE[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     15315, 15319, 15323, 15327, 15331, 15335, 15339, 15343,
     15347, 15351, 15355, 15359, 15363, 15367, 15371, 15375,
     15379, 15383, 15387, 15391, 15395, 0, 0, 0,
     0, 15399, 15403, 15407, 15411, 15415, 15419, 15423,
     15427, 15431, 15435, 0, 15439, 15443, 15447, 15451,
     15455, 15459, 15463, 15467, 15471, 15475, 15479, 15483,
     15487, 15491, 15495, 15499, 15503, 15507, 15511, 0,
     15515, 15519, 15523, 15527, 0, 0, 0, 0,
     15531, 15536, 15541, 0, 15546, 0, 15551, 15556,
     15561, 15566, 15571, 15576, 15581, 15586, 15591, 15596,
     15601, 15605, 15609, 15613, 15617, 15621, 15625, 15629,
     15633, 15637, 15641, 15645, 15649, 15653, 15657, 15661,
     15665, 15669, 15673, 15677, 15681, 15685, 15689, 15693,
     15697, 15701, 15705, 15709, 15713, 15717, 15721, 15725,
     15729, 15733, 15737, 15741, 15745, 15749, 15753, 15757,
     15761, 15765, 15769, 15773, 15777, 15781, 15785, 15789,
     15793, 15797, 15801, 15805, 15809, 15813, 15817, 15821,
     15825, 15829, 15833, 15837, 15841, 15845, 15849, 15853,
     15857, 15861, 15865, 15869, 15873, 15877, 15881, 15885,
     15889, 15893, 15897, 15901, 15905, 15909, 15913, 15917,
     15921, 15925, 15929, 15933, 15937, 15941, 15945, 15949,
     15953, 15957, 15961, 15965, 15969, 15973, 15977, 15981,
     15985, 15989, 15993, 15997, 16001, 16005, 16009, 16013,
     16017, 16021, 16025, 16029, 16033, 16037, 16041, 16045,
     16049, 16053, 16057, 16061, 16065, 16069, 16074, 16079,
     16084, 16089, 16094, 16099, 16104, 0, 0, 0,
 };
 
 static const Q_UINT16 di_FF[] = {
     0, 16109, 16113, 16117, 16121, 16125, 16129, 16133,
     16137, 16141, 16145, 16149, 16153, 16157, 16161, 16165,
     16169, 16173, 16177, 16181, 16185, 16189, 16193, 16197,
     16201, 16205, 16209, 16213, 16217, 16221, 16225, 16229,
     16233, 16237, 16241, 16245, 16249, 16253, 16257, 16261,
     16265, 16269, 16273, 16277, 16281, 16285, 16289, 16293,
     16297, 16301, 16305, 16309, 16313, 16317, 16321, 16325,
     16329, 16333, 16337, 16341, 16345, 16349, 16353, 16357,
     16361, 16365, 16369, 16373, 16377, 16381, 16385, 16389,
     16393, 16397, 16401, 16405, 16409, 16413, 16417, 16421,
     16425, 16429, 16433, 16437, 16441, 16445, 16449, 16453,
     16457, 16461, 16465, 16469, 16473, 16477, 16481, 16485,
     16489, 16493, 16497, 16501, 16505, 16509, 16513, 16517,
     16521, 16525, 16529, 16533, 16537, 16541, 16545, 16549,
     16553, 16557, 16561, 16565, 16569, 16573, 16577, 16581,
     16585, 16589, 16593, 16597, 16601, 16605, 16609, 16613,
     16617, 16621, 16625, 16629, 16633, 16637, 16641, 16645,
     16649, 16653, 16657, 16661, 16665, 16669, 16673, 16677,
     16681, 16685, 16689, 16693, 16697, 16701, 16705, 16709,
     16713, 16717, 16721, 16725, 16729, 16733, 16737, 16741,
     16745, 16749, 16753, 16757, 16761, 16765, 16769, 16773,
     16777, 16781, 16785, 16789, 16793, 16797, 16801, 16805,
     16809, 16813, 16817, 16821, 16825, 16829, 16833, 16837,
     16841, 16845, 16849, 16853, 16857, 16861, 16865, 0,
     0, 0, 16869, 16873, 16877, 16881, 16885, 16889,
     0, 0, 16893, 16897, 16901, 16905, 16909, 16913,
     0, 0, 16917, 16921, 16925, 16929, 16933, 16937,
     0, 0, 16941, 16945, 16949, 0, 0, 0,
     16953, 16957, 16961, 16965, 16969, 16973, 16977, 0,
     16981, 16985, 16989, 16993, 16997, 17001, 17005, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 * const decomposition_info[256] = {
     di_00, di_01, di_02, di_03, di_04, di_05, di_06, di_07,
     di_07, di_09, di_0A, di_0B, di_0C, di_0D, di_0E, di_0F,
     di_10, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_1E, di_1F,
     di_20, di_21, di_22, di_23, di_24, di_07, di_07, di_07,
     di_07, di_07, di_2A, di_07, di_07, di_07, di_2E, di_2F,
     di_30, di_31, di_32, di_33, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_07, di_07, di_07, di_07, di_07, di_07, di_07,
     di_07, di_F9, di_FA, di_FB, di_FC, di_FD, di_FE, di_FF,
 };
 // 68832 bytes
 
 static const Q_UINT16 ligature_map[] = {
     0,
     5567, 0,
     5552, 0,
     5572, 0,
     67, 72, 77, 82, 87, 92, 332, 342, 352, 966, 1196, 1206, 1346, 2365, 3145, 3155, 0,
     2375, 2385, 2395, 0,
     97, 362, 372, 382, 392, 0,
     402, 2415, 2425, 2435, 2445, 2455, 0,
     102, 107, 112, 117, 412, 422, 432, 442, 452, 1216, 1226, 1356, 2485, 2495, 3265, 3275, 3285, 0,
     2515, 0,
     462, 472, 482, 492, 1076, 1146, 2525, 0,
     502, 1336, 2535, 2545, 2555, 2565, 2575, 0,
     122, 127, 132, 137, 512, 522, 532, 542, 552, 976, 1236, 1246, 2585, 3345, 3355, 0,
     567, 0,
     577, 1086, 2605, 2615, 2625, 0,
     587, 597, 607, 2635, 2655, 2665, 0,
     2675, 2685, 2695, 0,
     142, 627, 637, 647, 1156, 2705, 2715, 2725, 2735, 0,
     147, 152, 157, 162, 167, 662, 672, 682, 901, 986, 1096, 1256, 1266, 1386, 3365, 3375, 0,
     2785, 2795, 0,
     692, 702, 712, 1276, 1286, 2805, 2815, 2835, 0,
     722, 732, 742, 752, 1316, 2845, 2855, 0,
     762, 772, 1326, 2895, 2905, 2915, 2925, 0,
     172, 177, 182, 187, 782, 792, 802, 812, 822, 832, 911, 996, 1296, 1306, 2935, 2945, 2955, 3485, 3495, 0,
     2985, 2995, 0,
     842, 3005, 3015, 3025, 3035, 3045, 0,
     3055, 3065, 0,
     192, 852, 862, 1406, 3075, 3555, 3565, 3575, 3585, 0,
     867, 877, 887, 3085, 3095, 3105, 0,
     197, 202, 207, 212, 217, 222, 337, 347, 357, 971, 1201, 1211, 1351, 2370, 3150, 3160, 0,
     2380, 2390, 2400, 0,
     227, 367, 377, 387, 397, 0,
     407, 2420, 2430, 2440, 2450, 2460, 0,
     232, 237, 242, 247, 417, 427, 437, 447, 457, 1221, 1231, 1361, 2490, 2500, 3270, 3280, 3290, 0,
     2520, 0,
     467, 477, 487, 497, 1081, 1151, 2530, 0,
     507, 1341, 2540, 2550, 2560, 2570, 2580, 3115, 0,
     252, 257, 262, 267, 517, 527, 537, 547, 981, 1241, 1251, 2590, 3350, 3360, 0,
     572, 1126, 0,
     582, 1091, 2610, 2620, 2630, 0,
     592, 602, 612, 2640, 2660, 2670, 0,
     2680, 2690, 2700, 0,
     272, 632, 642, 652, 1161, 2710, 2720, 2730, 2740, 0,
     277, 282, 287, 292, 297, 667, 677, 687, 906, 991, 1101, 1261, 1271, 1391, 3370, 3380, 0,
     2790, 2800, 0,
     697, 707, 717, 1281, 1291, 2810, 2820, 2840, 0,
     727, 737, 747, 757, 1321, 2850, 2860, 0,
     767, 777, 1331, 2900, 2910, 2920, 2930, 3120, 0,
     302, 307, 312, 317, 787, 797, 807, 817, 827, 837, 916, 1001, 1301, 1311, 2940, 2950, 2960, 3490, 3500, 0,
     2990, 3000, 0,
     847, 3010, 3020, 3030, 3040, 3050, 3125, 0,
     3060, 3070, 0,
     322, 327, 857, 1411, 3080, 3130, 3560, 3570, 3580, 3590, 0,
     872, 882, 892, 3090, 3100, 3110, 0,
     1537, 4476, 4670, 0,
     3165, 3175, 3185, 3195, 0,
     1046, 0,
     1166, 0,
     1066, 1176, 0,
     2405, 0,
     3295, 3305, 3315, 3325, 0,
     2595, 0,
     3385, 3395, 3405, 3415, 0,
     1376, 2745, 2755, 0,
     1366, 0,
     1186, 0,
     1006, 1016, 1026, 1036, 0,
     3170, 3180, 3190, 3200, 0,
     1051, 0,
     1171, 0,
     1071, 1181, 0,
     2410, 0,
     3300, 3310, 3320, 3330, 0,
     2600, 0,
     3390, 3400, 3410, 3420, 0,
     1381, 2750, 2760, 0,
     1371, 0,
     1191, 0,
     1011, 1021, 1031, 1041, 0,
     3215, 3225, 3235, 3245, 0,
     3220, 3230, 3240, 3250, 0,
     2465, 2475, 0,
     2470, 2480, 0,
     2765, 2775, 0,
     2770, 2780, 0,
     2865, 0,
     2870, 0,
     2875, 0,
     2880, 0,
     2965, 0,
     2970, 0,
     2975, 0,
     2980, 0,
     3140, 0,
     3435, 3445, 3455, 3465, 3475, 0,
     3440, 3450, 3460, 3470, 3480, 0,
     3505, 3515, 3525, 3535, 3545, 0,
     3510, 3520, 3530, 3540, 3550, 0,
     1116, 0,
     1106, 0,
     1111, 0,
     1056, 0,
     1061, 0,
     2505, 0,
     2510, 0,
     1396, 0,
     1401, 0,
     1121, 0,
     1514, 0,
     1542, 3635, 3640, 4433, 4438, 4443, 4452, 0,
     1551, 3705, 3710, 4506, 0,
     1556, 3775, 3780, 4515, 4524, 0,
     1561, 1586, 3855, 3860, 4573, 4578, 4583, 0,
     1566, 3925, 3930, 4708, 0,
     4665, 0,
     1571, 1591, 3995, 4646, 4651, 4656, 0,
     1576, 4055, 4060, 4717, 4726, 0,
     4418, 0,
     4491, 0,
     1596, 3595, 3600, 4095, 4398, 4403, 4413, 4423, 0,
     1601, 3675, 3680, 4104, 0,
     1606, 3735, 3740, 4113, 4486, 4496, 0,
     1611, 1621, 3815, 3820, 4122, 4544, 4549, 4563, 0,
     1631, 3895, 3900, 4131, 0,
     4626, 4631, 0,
     1626, 1636, 3955, 3960, 4140, 4607, 4612, 4636, 0,
     1641, 4015, 4020, 4149, 4688, 4698, 0,
     1581, 4554, 4568, 0,
     1616, 4617, 4641, 0,
     4693, 0,
     1658, 1663, 0,
     1711, 0,
     1796, 1806, 0,
     1706, 0,
     1696, 1701, 1816, 0,
     1786, 1836, 0,
     1846, 0,
     1721, 1731, 1856, 1866, 0,
     1716, 0,
     1876, 0,
     1726, 1906, 1916, 1926, 0,
     1936, 0,
     1946, 0,
     1896, 0,
     1801, 1811, 0,
     1751, 0,
     1741, 1746, 1821, 0,
     1791, 1841, 0,
     1851, 0,
     1736, 1766, 1861, 1871, 0,
     1761, 0,
     1881, 0,
     1771, 1911, 1921, 1931, 0,
     1941, 0,
     1951, 0,
     1901, 0,
     1756, 0,
     1776, 0,
     1781, 0,
     1826, 0,
     1831, 0,
     1886, 0,
     1891, 0,
     12167, 12172, 12177, 0,
     12182, 12292, 0,
     12187, 0,
     12192, 0,
     12197, 0,
     12202, 12287, 0,
     12207, 0,
     12212, 0,
     12097, 12217, 0,
     12222, 0,
     12227, 12297, 0,
     12232, 0,
     12237, 0,
     12242, 0,
     12247, 0,
     12252, 0,
     12257, 12302, 0,
     12262, 0,
     12267, 0,
     12272, 0,
     12147, 12152, 12277, 0,
     12282, 0,
     12102, 0,
     1961, 1966, 1976, 0,
     1971, 0,
     1981, 0,
     2011, 0,
     2016, 0,
     2006, 0,
     2036, 0,
     2041, 0,
     2046, 0,
     2051, 0,
     2056, 0,
     2061, 0,
     2021, 0,
     2066, 0,
     2071, 0,
     2026, 0,
     2031, 0,
     2086, 0,
     2091, 0,
     2096, 0,
     2076, 2081, 0,
     2111, 0,
     2116, 0,
     2121, 0,
     2126, 0,
     2101, 0,
     2106, 0,
     2146, 0,
     2151, 0,
     2131, 2136, 2141, 0,
     2156, 0,
     2161, 2171, 0,
     2166, 0,
     2176, 0,
     2181, 0,
     2186, 2191, 2196, 0,
     2201, 0,
     2206, 2216, 0,
     2211, 0,
     2221, 2226, 2236, 0,
     2231, 0,
     2290, 0,
     2265, 0,
     2270, 0,
     2275, 0,
     2280, 0,
     2285, 0,
     2295, 2300, 2325, 0,
     2355, 0,
     2330, 0,
     2335, 0,
     2340, 0,
     2345, 0,
     2350, 0,
     2305, 0,
     2315, 0,
     2360, 0,
     2645, 0,
     2650, 0,
     2825, 0,
     2830, 0,
     2885, 0,
     2890, 0,
     3205, 3255, 0,
     3210, 3260, 0,
     3335, 0,
     3340, 0,
     3425, 0,
     3430, 0,
     3605, 3615, 3625, 4158, 0,
     3610, 3620, 3630, 4163, 0,
     4168, 0,
     4173, 0,
     4178, 0,
     4183, 0,
     4188, 0,
     4193, 0,
     3645, 3655, 3665, 4198, 0,
     3650, 3660, 3670, 4203, 0,
     4208, 0,
     4213, 0,
     4218, 0,
     4223, 0,
     4228, 0,
     4233, 0,
     3685, 3695, 0,
     3690, 3700, 0,
     3715, 3725, 0,
     3720, 3730, 0,
     3745, 3755, 3765, 4238, 0,
     3750, 3760, 3770, 4243, 0,
     4248, 0,
     4253, 0,
     4258, 0,
     4263, 0,
     4268, 0,
     4273, 0,
     3785, 3795, 3805, 4278, 0,
     3790, 3800, 3810, 4283, 0,
     4288, 0,
     4293, 0,
     4298, 0,
     4303, 0,
     4308, 0,
     4313, 0,
     3825, 3835, 3845, 0,
     3830, 3840, 3850, 0,
     3865, 3875, 3885, 0,
     3870, 3880, 3890, 0,
     3905, 3915, 0,
     3910, 3920, 0,
     3935, 3945, 0,
     3940, 3950, 0,
     3965, 3975, 3985, 0,
     3970, 3980, 3990, 0,
     4000, 4005, 4010, 0,
     4025, 4035, 4045, 4318, 0,
     4030, 4040, 4050, 4323, 0,
     4328, 0,
     4333, 0,
     4338, 0,
     4343, 0,
     4348, 0,
     4353, 0,
     4065, 4075, 4085, 4358, 0,
     4070, 4080, 4090, 4363, 0,
     4368, 0,
     4373, 0,
     4378, 0,
     4383, 0,
     4388, 0,
     4393, 0,
     4408, 0,
     4481, 0,
     4683, 0,
     4428, 0,
     4529, 4534, 4539, 0,
     4501, 0,
     4703, 0,
     4592, 4597, 4602, 0,
     5455, 0,
     5460, 0,
     5465, 0,
     5470, 0,
     5480, 0,
     5475, 0,
     5485, 0,
     5490, 0,
     5495, 0,
     5500, 0,
     5505, 0,
     5532, 0,
     5537, 0,
     5542, 0,
     5547, 0,
     5562, 0,
     5557, 0,
     5577, 0,
     5582, 0,
     5587, 0,
     5592, 0,
     5597, 0,
     5602, 0,
     5607, 0,
     5612, 0,
     5657, 0,
     5662, 0,
     5617, 0,
     5622, 0,
     5627, 0,
     5632, 0,
     5667, 0,
     5672, 0,
     5637, 0,
     5642, 0,
     5647, 0,
     5652, 0,
     5677, 0,
     5682, 0,
     5687, 0,
     5692, 0,
     6430, 0,
     7444, 0,
     7319, 0,
     7324, 0,
     7329, 0,
     7334, 0,
     7339, 0,
     7344, 0,
     7349, 0,
     7354, 0,
     7359, 0,
     7364, 0,
     7369, 0,
     7374, 0,
     7379, 0,
     7384, 0,
     7389, 0,
     7394, 7399, 0,
     7404, 7409, 0,
     7414, 7419, 0,
     7424, 7429, 0,
     7434, 7439, 0,
     7459, 0,
     7594, 0,
     7469, 0,
     7474, 0,
     7479, 0,
     7484, 0,
     7489, 0,
     7494, 0,
     7499, 0,
     7504, 0,
     7509, 0,
     7514, 0,
     7519, 0,
     7524, 0,
     7529, 0,
     7534, 0,
     7539, 0,
     7544, 7549, 0,
     7554, 7559, 0,
     7564, 7569, 0,
     7574, 7579, 0,
     7584, 7589, 0,
     7599, 0,
     7604, 0,
     7609, 0,
     7614, 0,
     7619, 0,
     12157, 12162, 0,
 
 };
 
 static const Q_UINT16 li_00[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 1, 3, 5, 0,
     0, 7, 24, 28, 34, 41, 59, 61,
     69, 77, 93, 95, 101, 108, 112, 122,
     139, 0, 142, 151, 159, 167, 187, 190,
     197, 200, 210, 0, 0, 0, 0, 0,
     0, 217, 234, 238, 244, 251, 269, 271,
     279, 288, 303, 306, 312, 319, 323, 333,
     350, 0, 353, 362, 370, 379, 399, 402,
     410, 413, 424, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     431, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 435, 0, 440, 442, 444, 447,
     0, 0, 449, 0, 0, 0, 0, 454,
     0, 0, 0, 0, 456, 461, 465, 0,
     467, 0, 0, 0, 469, 0, 0, 0,
     0, 0, 474, 0, 479, 481, 483, 486,
     0, 0, 488, 0, 0, 0, 0, 493,
     0, 0, 0, 0, 495, 500, 504, 0,
     506, 0, 0, 0, 508, 0, 0, 0,
 };
 
 static const Q_UINT16 li_01[] = {
     0, 0, 513, 518, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 523, 526, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 529, 532, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 535, 537, 0, 0, 0, 0,
     539, 541, 0, 0, 0, 0, 0, 0,
     543, 545, 547, 549, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 551,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     553, 559, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 565,
     571, 0, 0, 0, 0, 0, 0, 577,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 579, 581, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_02[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 583, 585,
     587, 589, 0, 0, 0, 0, 591, 593,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 595, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_03[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     597, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 599, 0, 0, 0, 607, 0, 612,
     0, 618, 0, 0, 0, 0, 0, 626,
     0, 631, 0, 0, 0, 633, 0, 0,
     0, 640, 0, 0, 646, 0, 648, 0,
     0, 650, 0, 0, 0, 659, 0, 664,
     0, 671, 0, 0, 0, 0, 0, 680,
     0, 685, 0, 0, 0, 688, 0, 0,
     0, 697, 704, 708, 0, 0, 712, 0,
     0, 0, 714, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_04[] = {
     0, 0, 0, 0, 0, 0, 717, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     719, 0, 0, 722, 0, 724, 728, 731,
     733, 0, 738, 0, 0, 0, 740, 0,
     0, 0, 0, 742, 0, 0, 0, 747,
     0, 0, 0, 749, 0, 751, 0, 0,
     753, 0, 0, 756, 0, 758, 762, 765,
     767, 0, 772, 0, 0, 0, 774, 0,
     0, 0, 0, 776, 0, 0, 0, 781,
     0, 0, 0, 783, 0, 785, 0, 0,
     0, 0, 0, 0, 0, 0, 787, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 789, 791, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     793, 795, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     797, 799, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_05[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     801, 805, 808, 810, 812, 814, 817, 0,
     819, 821, 824, 826, 829, 0, 831, 0,
     833, 835, 0, 837, 839, 0, 842, 844,
     846, 848, 852, 0, 0, 0, 0, 0,
     0, 0, 854, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_06[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 856,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     860, 0, 862, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 864, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 866, 0, 0, 868, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_07[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_09[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 870, 872, 874,
     0, 0, 0, 0, 876, 0, 0, 0,
     0, 878, 880, 0, 0, 0, 0, 0,
     882, 0, 0, 884, 0, 0, 0, 886,
     888, 0, 0, 890, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 892, 894, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 896,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 898,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_0A[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 901, 903,
     0, 0, 0, 0, 905, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 907, 0, 0, 0, 0,
     0, 0, 909, 0, 0, 0, 0, 0,
     911, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_0B[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 913, 915, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 917,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 921, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 923, 926,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_0C[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 928, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 930,
     0, 0, 0, 0, 0, 0, 932, 0,
     0, 0, 936, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_0D[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 938, 941,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 943, 0, 0, 947, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_0F[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     949, 0, 951, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 953, 0, 0, 0,
     0, 955, 0, 0, 0, 0, 957, 0,
     0, 0, 0, 959, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 961, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     965, 0, 967, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 969, 0, 0, 0,
     0, 971, 0, 0, 0, 0, 973, 0,
     0, 0, 0, 975, 0, 0, 0, 0,
     0, 0, 977, 979, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_10[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 981, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_1E[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 983, 985,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 987, 989, 0, 0, 0, 0,
     0, 0, 991, 993, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     995, 998, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1001, 1003, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 1005, 1007, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_1F[] = {
     1009, 1014, 1019, 1021, 1023, 1025, 1027, 1029,
     1031, 1036, 1041, 1043, 1045, 1047, 1049, 1051,
     1053, 1056, 0, 0, 0, 0, 0, 0,
     1059, 1062, 0, 0, 0, 0, 0, 0,
     1065, 1070, 1075, 1077, 1079, 1081, 1083, 1085,
     1087, 1092, 1097, 1099, 1101, 1103, 1105, 1107,
     1109, 1113, 0, 0, 0, 0, 0, 0,
     1117, 1121, 0, 0, 0, 0, 0, 0,
     1125, 1128, 0, 0, 0, 0, 0, 0,
     1131, 1134, 0, 0, 0, 0, 0, 0,
     1137, 1141, 0, 0, 0, 0, 0, 0,
     0, 1145, 0, 0, 0, 0, 0, 0,
     1149, 1154, 1159, 1161, 1163, 1165, 1167, 1169,
     1171, 1176, 1181, 1183, 1185, 1187, 1189, 1191,
     1193, 0, 0, 0, 1195, 0, 0, 0,
     0, 0, 0, 0, 1197, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 1199, 0,
     0, 0, 0, 0, 0, 0, 0, 1201,
     0, 0, 0, 0, 0, 0, 1205, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 1207, 0,
     0, 0, 0, 0, 0, 0, 1209, 0,
 };
 
 static const Q_UINT16 li_21[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1213, 0, 1215, 0, 1217, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1219, 0, 1221, 0, 1223, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_22[] = {
     0, 0, 0, 1225, 0, 0, 0, 0,
     1227, 0, 0, 1229, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 1231, 0, 1233, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 1235, 0, 0, 0,
     0, 0, 0, 1237, 0, 1239, 0, 0,
     1241, 0, 0, 0, 0, 1243, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 1245, 0, 0, 1247, 1249, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 1251, 1253, 0, 0, 1255, 1257,
     0, 0, 1259, 1261, 1263, 1265, 0, 0,
     0, 0, 1267, 1269, 0, 0, 1271, 1273,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 1275, 1277, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 1279, 0, 0, 0, 0, 0,
     1281, 1283, 0, 1285, 0, 0, 0, 0,
     0, 0, 1287, 1289, 1291, 1293, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_2A[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 1295, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 li_30[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 1297, 0,
     0, 0, 0, 1299, 0, 1301, 0, 1303,
     0, 1305, 0, 1307, 0, 1309, 0, 1311,
     0, 1313, 0, 1315, 0, 1317, 0, 1319,
     0, 1321, 0, 0, 1323, 0, 1325, 0,
     1327, 0, 0, 0, 0, 0, 0, 1329,
     0, 0, 1332, 0, 0, 1335, 0, 0,
     1338, 0, 0, 1341, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 1344, 0, 0,
     0, 0, 0, 0, 0, 0, 1346, 0,
     0, 0, 0, 1348, 0, 1350, 0, 1352,
     0, 1354, 0, 1356, 0, 1358, 0, 1360,
     0, 1362, 0, 1364, 0, 1366, 0, 1368,
     0, 1370, 0, 0, 1372, 0, 1374, 0,
     1376, 0, 0, 0, 0, 0, 0, 1378,
     0, 0, 1381, 0, 0, 1384, 0, 0,
     1387, 0, 0, 1390, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 1393,
     1395, 1397, 1399, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 1401, 0, 0,
 };
 
 static const Q_UINT16 li_FB[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 1403, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 * const ligature_info[256] = {
     li_00, li_01, li_02, li_03, li_04, li_05, li_06, li_07,
     li_07, li_09, li_0A, li_0B, li_0C, li_0D, li_07, li_0F,
     li_10, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_1E, li_1F,
     li_07, li_21, li_22, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_2A, li_07, li_07, li_07, li_07, li_07,
     li_30, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_07, li_07, li_07, li_07, li_07,
     li_07, li_07, li_07, li_FB, li_07, li_07, li_07, li_07,
 };
 // 15098 bytes
 
 static const Q_UINT8 dir_00[] = {
     18, 18, 18, 18, 18, 18, 18, 18,
     18, 8, 7, 8, 9, 7, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 7, 7, 7, 8,
     9, 10, 10, 4, 4, 4, 10, 10,
     138, 138, 10, 4, 6, 4, 6, 3,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 6, 10, 138, 10, 138, 10,
     10, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 138, 10, 138, 10, 10,
     10, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 138, 10, 138, 10, 18,
     18, 18, 18, 18, 18, 7, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18,
     6, 10, 4, 4, 4, 4, 10, 10,
     10, 10, 0, 138, 10, 10, 10, 10,
     4, 4, 2, 2, 10, 0, 10, 10,
     10, 2, 0, 138, 10, 10, 10, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_01[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_02[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 10, 10, 0, 0, 0, 0, 0,
     0, 0, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     0, 0, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     0, 0, 0, 0, 0, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_03[] = {
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     0, 0, 0, 0, 10, 10, 0, 0,
     0, 0, 0, 0, 0, 0, 10, 0,
     0, 0, 0, 0, 10, 10, 0, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 10, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_04[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 17, 17, 17, 17, 0,
     17, 17, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_05[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 10, 0, 0, 0, 0, 0,
     0, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 0, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 0, 17, 17, 17, 1, 17,
     1, 17, 17, 1, 17, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 0, 0, 0, 0, 0,
     1, 1, 1, 1, 1, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_06[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 6, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 13, 0, 0, 0, 13,
     0, 13, 77, 77, 77, 77, 45, 77,
     45, 77, 45, 45, 45, 45, 45, 77,
     77, 77, 77, 45, 45, 45, 45, 45,
     45, 45, 45, 0, 0, 0, 0, 0,
     109, 45, 45, 45, 45, 45, 45, 45,
     77, 45, 45, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     5, 5, 5, 5, 5, 5, 5, 5,
     5, 5, 4, 5, 5, 13, 45, 45,
     17, 77, 77, 77, 13, 77, 77, 77,
     45, 45, 45, 45, 45, 45, 45, 45,
     45, 45, 45, 45, 45, 45, 45, 45,
     77, 77, 77, 77, 77, 77, 77, 77,
     77, 77, 77, 77, 77, 77, 77, 77,
     77, 77, 45, 45, 45, 45, 45, 45,
     45, 45, 45, 45, 45, 45, 45, 45,
     45, 45, 45, 45, 45, 45, 45, 45,
     45, 45, 45, 45, 45, 45, 45, 45,
     45, 45, 45, 45, 45, 45, 45, 45,
     77, 45, 77, 77, 77, 77, 77, 77,
     77, 77, 77, 77, 45, 77, 45, 77,
     45, 45, 77, 77, 13, 77, 17, 17,
     17, 17, 17, 17, 17, 13, 17, 17,
     17, 17, 17, 17, 17, 13, 13, 17,
     17, 10, 17, 17, 17, 17, 0, 0,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 45, 45, 45, 13, 13, 0,
 };
 
 static const Q_UINT8 dir_07[] = {
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 0, 18,
     77, 17, 45, 45, 45, 77, 77, 77,
     77, 77, 45, 45, 45, 45, 77, 45,
     45, 45, 45, 45, 45, 45, 45, 45,
     77, 45, 77, 45, 77, 0, 0, 0,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 13, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_09[] = {
     0, 17, 17, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 17, 0, 0, 0,
     0, 17, 17, 17, 17, 17, 17, 17,
     17, 0, 0, 0, 0, 17, 0, 0,
     0, 17, 17, 17, 17, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 17, 17, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 17, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 17, 0, 0, 0,
     0, 17, 17, 17, 17, 0, 0, 0,
     0, 0, 0, 0, 0, 17, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 17, 17, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 4, 4, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_0A[] = {
     0, 0, 17, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 17, 0, 0, 0,
     0, 17, 17, 0, 0, 0, 0, 17,
     17, 0, 0, 17, 17, 17, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     17, 17, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 17, 17, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 17, 0, 0, 0,
     0, 17, 17, 17, 17, 17, 0, 17,
     17, 0, 0, 0, 0, 17, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_0B[] = {
     0, 17, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 17, 0, 0, 17,
     0, 17, 17, 17, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 17, 0, 0,
     0, 0, 0, 0, 0, 0, 17, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 17, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     17, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 17, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_0C[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 17, 17,
     17, 0, 0, 0, 0, 0, 17, 17,
     17, 0, 17, 17, 17, 17, 0, 0,
     0, 0, 0, 0, 0, 17, 17, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 17,
     0, 0, 0, 0, 0, 0, 17, 0,
     0, 0, 0, 0, 17, 17, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_0D[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 17, 17, 17, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 17, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 17, 0, 0, 0, 0, 0,
     0, 0, 17, 17, 17, 0, 17, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_0E[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 17, 0, 0, 17, 17, 17, 17,
     17, 17, 17, 0, 0, 0, 0, 4,
     0, 0, 0, 0, 0, 0, 0, 17,
     17, 17, 17, 17, 17, 17, 17, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 17, 0, 0, 17, 17, 17, 17,
     17, 17, 0, 17, 17, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     17, 17, 17, 17, 17, 17, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_0F[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     17, 17, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 17, 0, 17,
     0, 17, 10, 10, 10, 10, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 0,
     17, 17, 17, 17, 17, 0, 17, 17,
     0, 0, 0, 0, 0, 0, 0, 0,
     17, 17, 17, 17, 17, 17, 17, 17,
     0, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 17, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_10[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 17, 17, 17,
     17, 0, 17, 0, 0, 0, 17, 17,
     0, 17, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     17, 17, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_16[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     9, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 10, 10, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_17[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 17, 17, 17, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 17, 17, 17, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 17, 17, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 17, 17, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 17,
     17, 17, 17, 17, 17, 17, 0, 0,
     0, 0, 0, 0, 0, 0, 17, 0,
     0, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 0, 0, 0, 0,
     0, 0, 0, 4, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_18[] = {
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 17, 17, 17, 18, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 17, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_1F[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 10, 0, 10,
     10, 10, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 10, 10, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 10, 10, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 10, 10, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 10, 10, 0,
 };
 
 static const Q_UINT8 dir_20[] = {
     9, 9, 9, 9, 9, 9, 9, 9,
     9, 9, 9, 18, 18, 114, 0, 1,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     9, 7, 11, 14, 16, 12, 15, 9,
     4, 4, 4, 4, 4, 10, 10, 10,
     10, 138, 138, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 138, 138, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 0, 0, 0, 0, 10,
     0, 0, 0, 0, 0, 0, 0, 9,
     18, 18, 18, 18, 0, 0, 0, 0,
     0, 0, 18, 18, 18, 18, 18, 18,
     2, 0, 0, 0, 2, 2, 2, 2,
     2, 2, 4, 4, 10, 138, 138, 0,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 4, 4, 10, 138, 138, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 4, 4, 4, 4, 4, 4,
     4, 4, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_21[] = {
     10, 10, 0, 10, 10, 10, 10, 0,
     10, 10, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 10, 0, 10, 10,
     10, 0, 0, 0, 0, 0, 10, 10,
     10, 10, 10, 10, 0, 10, 0, 10,
     0, 10, 0, 0, 0, 0, 4, 0,
     0, 0, 10, 0, 0, 0, 0, 0,
     0, 0, 10, 0, 0, 0, 0, 0,
     138, 10, 10, 10, 10, 0, 0, 0,
     0, 0, 10, 10, 0, 0, 0, 0,
     0, 0, 0, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
 };
 
 static const Q_UINT8 dir_22[] = {
     10, 138, 138, 138, 138, 10, 10, 10,
     138, 138, 138, 138, 138, 138, 10, 10,
     10, 138, 4, 4, 10, 138, 138, 10,
     10, 10, 138, 138, 138, 138, 10, 138,
     138, 138, 138, 10, 138, 10, 138, 10,
     10, 10, 10, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 10, 10, 10, 10,
     10, 138, 10, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 10, 10, 10,
     10, 10, 138, 138, 138, 138, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 138,
     138, 10, 138, 10, 138, 138, 138, 138,
     138, 138, 138, 138, 10, 10, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 10, 10, 138,
     138, 138, 138, 10, 10, 10, 10, 10,
     138, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 138, 138, 10, 10, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 10, 10, 10, 10, 10, 138, 138,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 138, 138, 138, 138, 138, 10, 10,
     138, 138, 10, 10, 10, 10, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 10, 10,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
 };
 
 static const Q_UINT8 dir_23[] = {
     10, 10, 10, 10, 10, 10, 10, 10,
     138, 138, 138, 138, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     138, 138, 10, 10, 10, 10, 10, 10,
     10, 138, 138, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 0, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_24[] = {
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 2, 2, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 2, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 0,
 };
 
 static const Q_UINT8 dir_25[] = {
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
 };
 
 static const Q_UINT8 dir_26[] = {
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 0, 0, 10, 10,
     0, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 0, 0,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_27[] = {
     0, 10, 10, 10, 10, 0, 10, 10,
     10, 10, 0, 0, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     0, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 0, 10, 0, 10,
     10, 10, 10, 0, 0, 0, 10, 0,
     10, 10, 10, 10, 10, 10, 10, 0,
     0, 10, 10, 10, 10, 10, 10, 10,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 0, 0, 0,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     0, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     10, 10, 10, 138, 138, 138, 138, 10,
     10, 10, 10, 10, 138, 138, 138, 10,
     10, 10, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 0, 0, 0, 0,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
 };
 
 static const Q_UINT8 dir_29[] = {
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 10, 10, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     10, 10, 10, 10, 10, 10, 10, 10,
     138, 10, 10, 10, 10, 10, 10, 10,
     138, 138, 138, 138, 138, 138, 10, 10,
     10, 138, 10, 10, 10, 10, 138, 138,
     138, 138, 138, 10, 138, 138, 10, 10,
     138, 138, 138, 138, 138, 10, 10, 10,
     10, 138, 10, 138, 138, 138, 10, 10,
     138, 138, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 138, 138, 138, 138,
     138, 138, 10, 10, 138, 138, 10, 10,
 };
 
 static const Q_UINT8 dir_2A[] = {
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 10, 138, 138,
     138, 138, 10, 10, 138, 10, 138, 10,
     10, 138, 10, 138, 138, 138, 138, 10,
     10, 10, 10, 10, 138, 138, 10, 10,
     10, 10, 10, 10, 138, 138, 138, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 138,
     138, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 138, 138, 10, 10,
     10, 10, 138, 138, 138, 138, 10, 138,
     138, 10, 10, 138, 138, 10, 10, 10,
     10, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 10, 10, 138, 138,
     138, 138, 138, 138, 138, 138, 10, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 138, 138, 138, 138, 138, 10,
     10, 10, 10, 10, 138, 10, 138, 10,
     10, 10, 138, 138, 138, 138, 138, 10,
     10, 10, 10, 10, 138, 138, 138, 10,
     10, 10, 10, 138, 10, 10, 10, 138,
     138, 138, 138, 138, 10, 138, 10, 10,
 };
 
 static const Q_UINT8 dir_2E[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 0, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_2F[] = {
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_30[] = {
     9, 10, 10, 10, 10, 0, 0, 0,
     138, 138, 138, 138, 138, 138, 138, 138,
     138, 138, 10, 10, 138, 138, 138, 138,
     138, 138, 138, 138, 10, 10, 10, 10,
     10, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 17, 17, 17, 17, 17, 17,
     10, 0, 0, 0, 0, 0, 10, 10,
     0, 0, 0, 0, 0, 10, 10, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 17, 17, 10, 10, 0, 0, 0,
     10, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 10, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_32[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_A4[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_FB[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 1, 17, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     1, 4, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 0,
     1, 1, 1, 1, 1, 0, 1, 0,
     1, 1, 0, 1, 1, 0, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
 };
 
 static const Q_UINT8 dir_FC[] = {
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
 };
 
 static const Q_UINT8 dir_FD[] = {
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 10, 10,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     0, 0, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 0, 0, 0,
 };
 
 static const Q_UINT8 dir_FE[] = {
     17, 17, 17, 17, 17, 17, 17, 17,
     17, 17, 17, 17, 17, 17, 17, 17,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     17, 17, 17, 17, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 0,
     0, 10, 10, 10, 10, 10, 10, 10,
     6, 10, 6, 0, 10, 6, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 4,
     10, 10, 4, 4, 10, 10, 10, 0,
     10, 4, 4, 10, 0, 0, 0, 0,
     13, 13, 13, 13, 13, 0, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 13, 13, 13,
     13, 13, 13, 13, 13, 0, 0, 18,
 };
 
 static const Q_UINT8 dir_FF[] = {
     0, 10, 10, 4, 4, 4, 10, 10,
     138, 138, 10, 4, 6, 4, 6, 3,
     2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 6, 10, 138, 10, 138, 10,
     10, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 138, 10, 138, 10, 10,
     10, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 138, 10, 138, 10, 138,
     138, 10, 138, 138, 10, 10, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     4, 4, 10, 10, 10, 4, 4, 0,
     10, 10, 10, 10, 10, 10, 10, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 18, 18, 18, 10, 10, 0, 0,
 };
 
 static const Q_UINT8 * const direction_info[256] = {
     dir_00, dir_01, dir_02, dir_03, dir_04, dir_05, dir_06, dir_07,
     dir_01, dir_09, dir_0A, dir_0B, dir_0C, dir_0D, dir_0E, dir_0F,
     dir_10, dir_01, dir_01, dir_01, dir_01, dir_01, dir_16, dir_17,
     dir_18, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_1F,
     dir_20, dir_21, dir_22, dir_23, dir_24, dir_25, dir_26, dir_27,
     dir_25, dir_29, dir_2A, dir_01, dir_01, dir_01, dir_2E, dir_2F,
     dir_30, dir_01, dir_32, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_A4, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01, dir_01,
     dir_01, dir_01, dir_01, dir_FB, dir_FC, dir_FD, dir_FE, dir_FF,
 };
 // 26362 bytes
 
 static const Q_UINT8 cmb_00[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_03[] = {
     230, 230, 230, 230, 230, 230, 230, 230,
     230, 230, 230, 230, 230, 230, 230, 230,
     230, 230, 230, 230, 230, 232, 220, 220,
     220, 220, 232, 216, 220, 220, 220, 220,
     220, 202, 202, 220, 220, 220, 220, 202,
     202, 220, 220, 220, 220, 220, 220, 220,
     220, 220, 220, 220, 1, 1, 1, 1,
     1, 220, 220, 220, 220, 230, 230, 230,
     230, 230, 230, 230, 230, 240, 230, 220,
     220, 220, 230, 230, 230, 220, 220, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     234, 234, 233, 230, 230, 230, 230, 230,
     230, 230, 230, 230, 230, 230, 230, 230,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_04[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 230, 230, 230, 230, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_05[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 220, 230, 230, 230, 230, 220, 230,
     230, 230, 222, 220, 230, 230, 230, 230,
     230, 230, 0, 220, 220, 220, 220, 220,
     230, 230, 220, 230, 230, 222, 228, 230,
     10, 11, 12, 13, 14, 15, 16, 17,
     18, 19, 0, 20, 21, 22, 0, 23,
     0, 24, 25, 0, 230, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_06[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 27, 28, 29, 30, 31,
     32, 33, 34, 230, 230, 220, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     35, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 230, 230,
     230, 230, 230, 230, 230, 0, 0, 230,
     230, 230, 230, 220, 230, 0, 0, 230,
     230, 0, 220, 230, 230, 220, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_07[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 36, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     230, 220, 230, 230, 220, 230, 230, 220,
     220, 220, 230, 220, 220, 230, 220, 230,
     230, 230, 220, 230, 220, 230, 220, 230,
     220, 230, 230, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_09[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 7, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 9, 0, 0,
     0, 230, 220, 230, 230, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 7, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 9, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_0A[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 7, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 9, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 7, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 9, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_0B[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 7, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 9, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 9, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_0C[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 9, 0, 0,
     0, 0, 0, 0, 0, 84, 91, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 9, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_0D[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 9, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 9, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_0E[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     103, 103, 9, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     107, 107, 107, 107, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     118, 118, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     122, 122, 122, 122, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_0F[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     220, 220, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 220, 0, 220,
     0, 216, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 129, 130, 0, 132, 0, 0, 0,
     0, 0, 130, 130, 130, 130, 0, 0,
     130, 0, 230, 230, 9, 0, 230, 230,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 220, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_10[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 7,
     0, 9, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_17[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 9, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 9, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 9, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_18[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 228, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_20[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     230, 230, 1, 1, 230, 230, 230, 230,
     1, 1, 1, 230, 230, 0, 0, 0,
     0, 230, 0, 0, 0, 1, 1, 230,
     220, 230, 1, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_30[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 218, 228, 232, 222, 224, 224,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 8, 8, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_FB[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 26, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 cmb_FE[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     230, 230, 230, 230, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT8 * const combining_info[256] = {
     cmb_00, cmb_00, cmb_00, cmb_03, cmb_04, cmb_05, cmb_06, cmb_07,
     cmb_00, cmb_09, cmb_0A, cmb_0B, cmb_0C, cmb_0D, cmb_0E, cmb_0F,
     cmb_10, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_17,
     cmb_18, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_20, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_30, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00, cmb_00,
     cmb_00, cmb_00, cmb_00, cmb_FB, cmb_00, cmb_00, cmb_FE, cmb_00,
 };
 // 32506 bytes
 
 static const Q_UINT16 case_00[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
     0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
     0x78, 0x79, 0x7a, 0, 0, 0, 0, 0,
     0, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
     0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
     0x58, 0x59, 0x5a, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0x39c, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
     0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0,
     0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0,
     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
     0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0,
     0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0x178,
 };
 
 static const Q_UINT16 case_01[] = {
     0x101, 0x100, 0x103, 0x102, 0x105, 0x104, 0x107, 0x106,
     0x109, 0x108, 0x10b, 0x10a, 0x10d, 0x10c, 0x10f, 0x10e,
     0x111, 0x110, 0x113, 0x112, 0x115, 0x114, 0x117, 0x116,
     0x119, 0x118, 0x11b, 0x11a, 0x11d, 0x11c, 0x11f, 0x11e,
     0x121, 0x120, 0x123, 0x122, 0x125, 0x124, 0x127, 0x126,
     0x129, 0x128, 0x12b, 0x12a, 0x12d, 0x12c, 0x12f, 0x12e,
     0x69, 0x49, 0x133, 0x132, 0x135, 0x134, 0x137, 0x136,
     0, 0x13a, 0x139, 0x13c, 0x13b, 0x13e, 0x13d, 0x140,
     0x13f, 0x142, 0x141, 0x144, 0x143, 0x146, 0x145, 0x148,
     0x147, 0, 0x14b, 0x14a, 0x14d, 0x14c, 0x14f, 0x14e,
     0x151, 0x150, 0x153, 0x152, 0x155, 0x154, 0x157, 0x156,
     0x159, 0x158, 0x15b, 0x15a, 0x15d, 0x15c, 0x15f, 0x15e,
     0x161, 0x160, 0x163, 0x162, 0x165, 0x164, 0x167, 0x166,
     0x169, 0x168, 0x16b, 0x16a, 0x16d, 0x16c, 0x16f, 0x16e,
     0x171, 0x170, 0x173, 0x172, 0x175, 0x174, 0x177, 0x176,
     0xff, 0x17a, 0x179, 0x17c, 0x17b, 0x17e, 0x17d, 0x53,
     0, 0x253, 0x183, 0x182, 0x185, 0x184, 0x254, 0x188,
     0x187, 0x256, 0x257, 0x18c, 0x18b, 0, 0x1dd, 0x259,
     0x25b, 0x192, 0x191, 0x260, 0x263, 0x1f6, 0x269, 0x268,
     0x199, 0x198, 0, 0, 0x26f, 0x272, 0x220, 0x275,
     0x1a1, 0x1a0, 0x1a3, 0x1a2, 0x1a5, 0x1a4, 0x280, 0x1a8,
     0x1a7, 0x283, 0, 0, 0x1ad, 0x1ac, 0x288, 0x1b0,
     0x1af, 0x28a, 0x28b, 0x1b4, 0x1b3, 0x1b6, 0x1b5, 0x292,
     0x1b9, 0x1b8, 0, 0, 0x1bd, 0x1bc, 0, 0x1f7,
     0, 0, 0, 0, 0x1c6, 0x1c4, 0x1c4, 0x1c9,
     0x1c7, 0x1c7, 0x1cc, 0x1ca, 0x1ca, 0x1ce, 0x1cd, 0x1d0,
     0x1cf, 0x1d2, 0x1d1, 0x1d4, 0x1d3, 0x1d6, 0x1d5, 0x1d8,
     0x1d7, 0x1da, 0x1d9, 0x1dc, 0x1db, 0x18e, 0x1df, 0x1de,
     0x1e1, 0x1e0, 0x1e3, 0x1e2, 0x1e5, 0x1e4, 0x1e7, 0x1e6,
     0x1e9, 0x1e8, 0x1eb, 0x1ea, 0x1ed, 0x1ec, 0x1ef, 0x1ee,
     0, 0x1f3, 0x1f1, 0x1f1, 0x1f5, 0x1f4, 0x195, 0x1bf,
     0x1f9, 0x1f8, 0x1fb, 0x1fa, 0x1fd, 0x1fc, 0x1ff, 0x1fe,
 };
 
 static const Q_UINT16 case_02[] = {
     0x201, 0x200, 0x203, 0x202, 0x205, 0x204, 0x207, 0x206,
     0x209, 0x208, 0x20b, 0x20a, 0x20d, 0x20c, 0x20f, 0x20e,
     0x211, 0x210, 0x213, 0x212, 0x215, 0x214, 0x217, 0x216,
     0x219, 0x218, 0x21b, 0x21a, 0x21d, 0x21c, 0x21f, 0x21e,
     0x19e, 0, 0x223, 0x222, 0x225, 0x224, 0x227, 0x226,
     0x229, 0x228, 0x22b, 0x22a, 0x22d, 0x22c, 0x22f, 0x22e,
     0x231, 0x230, 0x233, 0x232, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0x181, 0x186, 0, 0x189, 0x18a,
     0, 0x18f, 0, 0x190, 0, 0, 0, 0,
     0x193, 0, 0, 0x194, 0, 0, 0, 0,
     0x197, 0x196, 0, 0, 0, 0, 0, 0x19c,
     0, 0, 0x19d, 0, 0, 0x19f, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0x1a6, 0, 0, 0x1a9, 0, 0, 0, 0,
     0x1ae, 0, 0x1b1, 0x1b2, 0, 0, 0, 0,
     0, 0, 0x1b7, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 case_03[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0x399, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0x3ac, 0,
     0x3ad, 0x3ae, 0x3af, 0, 0x3cc, 0, 0x3cd, 0x3ce,
     0, 0x3b1, 0x3b2, 0x3b3, 0x3b4, 0x3b5, 0x3b6, 0x3b7,
     0x3b8, 0x3b9, 0x3ba, 0x3bb, 0x3bc, 0x3bd, 0x3be, 0x3bf,
     0x3c0, 0x3c1, 0, 0x3c3, 0x3c4, 0x3c5, 0x3c6, 0x3c7,
     0x3c8, 0x3c9, 0x3ca, 0x3cb, 0x386, 0x388, 0x389, 0x38a,
     0, 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397,
     0x398, 0x399, 0x39a, 0x39b, 0x39c, 0x39d, 0x39e, 0x39f,
     0x3a0, 0x3a1, 0x3a3, 0x3a3, 0x3a4, 0x3a5, 0x3a6, 0x3a7,
     0x3a8, 0x3a9, 0x3aa, 0x3ab, 0x38c, 0x38e, 0x38f, 0,
     0x392, 0x398, 0, 0, 0, 0x3a6, 0x3a0, 0,
     0x3d9, 0x3d8, 0x3db, 0x3da, 0x3dd, 0x3dc, 0x3df, 0x3de,
     0x3e1, 0x3e0, 0x3e3, 0x3e2, 0x3e5, 0x3e4, 0x3e7, 0x3e6,
     0x3e9, 0x3e8, 0x3eb, 0x3ea, 0x3ed, 0x3ec, 0x3ef, 0x3ee,
     0x39a, 0x3a1, 0x3a3, 0, 0x3b8, 0x395, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 case_04[] = {
     0x450, 0x451, 0x452, 0x453, 0x454, 0x455, 0x456, 0x457,
     0x458, 0x459, 0x45a, 0x45b, 0x45c, 0x45d, 0x45e, 0x45f,
     0x430, 0x431, 0x432, 0x433, 0x434, 0x435, 0x436, 0x437,
     0x438, 0x439, 0x43a, 0x43b, 0x43c, 0x43d, 0x43e, 0x43f,
     0x440, 0x441, 0x442, 0x443, 0x444, 0x445, 0x446, 0x447,
     0x448, 0x449, 0x44a, 0x44b, 0x44c, 0x44d, 0x44e, 0x44f,
     0x410, 0x411, 0x412, 0x413, 0x414, 0x415, 0x416, 0x417,
     0x418, 0x419, 0x41a, 0x41b, 0x41c, 0x41d, 0x41e, 0x41f,
     0x420, 0x421, 0x422, 0x423, 0x424, 0x425, 0x426, 0x427,
     0x428, 0x429, 0x42a, 0x42b, 0x42c, 0x42d, 0x42e, 0x42f,
     0x400, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407,
     0x408, 0x409, 0x40a, 0x40b, 0x40c, 0x40d, 0x40e, 0x40f,
     0x461, 0x460, 0x463, 0x462, 0x465, 0x464, 0x467, 0x466,
     0x469, 0x468, 0x46b, 0x46a, 0x46d, 0x46c, 0x46f, 0x46e,
     0x471, 0x470, 0x473, 0x472, 0x475, 0x474, 0x477, 0x476,
     0x479, 0x478, 0x47b, 0x47a, 0x47d, 0x47c, 0x47f, 0x47e,
     0x481, 0x480, 0, 0, 0, 0, 0, 0,
     0, 0, 0x48b, 0x48a, 0x48d, 0x48c, 0x48f, 0x48e,
     0x491, 0x490, 0x493, 0x492, 0x495, 0x494, 0x497, 0x496,
     0x499, 0x498, 0x49b, 0x49a, 0x49d, 0x49c, 0x49f, 0x49e,
     0x4a1, 0x4a0, 0x4a3, 0x4a2, 0x4a5, 0x4a4, 0x4a7, 0x4a6,
     0x4a9, 0x4a8, 0x4ab, 0x4aa, 0x4ad, 0x4ac, 0x4af, 0x4ae,
     0x4b1, 0x4b0, 0x4b3, 0x4b2, 0x4b5, 0x4b4, 0x4b7, 0x4b6,
     0x4b9, 0x4b8, 0x4bb, 0x4ba, 0x4bd, 0x4bc, 0x4bf, 0x4be,
     0, 0x4c2, 0x4c1, 0x4c4, 0x4c3, 0x4c6, 0x4c5, 0x4c8,
     0x4c7, 0x4ca, 0x4c9, 0x4cc, 0x4cb, 0x4ce, 0x4cd, 0,
     0x4d1, 0x4d0, 0x4d3, 0x4d2, 0x4d5, 0x4d4, 0x4d7, 0x4d6,
     0x4d9, 0x4d8, 0x4db, 0x4da, 0x4dd, 0x4dc, 0x4df, 0x4de,
     0x4e1, 0x4e0, 0x4e3, 0x4e2, 0x4e5, 0x4e4, 0x4e7, 0x4e6,
     0x4e9, 0x4e8, 0x4eb, 0x4ea, 0x4ed, 0x4ec, 0x4ef, 0x4ee,
     0x4f1, 0x4f0, 0x4f3, 0x4f2, 0x4f5, 0x4f4, 0, 0,
     0x4f9, 0x4f8, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 case_05[] = {
     0x501, 0x500, 0x503, 0x502, 0x505, 0x504, 0x507, 0x506,
     0x509, 0x508, 0x50b, 0x50a, 0x50d, 0x50c, 0x50f, 0x50e,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0x561, 0x562, 0x563, 0x564, 0x565, 0x566, 0x567,
     0x568, 0x569, 0x56a, 0x56b, 0x56c, 0x56d, 0x56e, 0x56f,
     0x570, 0x571, 0x572, 0x573, 0x574, 0x575, 0x576, 0x577,
     0x578, 0x579, 0x57a, 0x57b, 0x57c, 0x57d, 0x57e, 0x57f,
     0x580, 0x581, 0x582, 0x583, 0x584, 0x585, 0x586, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0x531, 0x532, 0x533, 0x534, 0x535, 0x536, 0x537,
     0x538, 0x539, 0x53a, 0x53b, 0x53c, 0x53d, 0x53e, 0x53f,
     0x540, 0x541, 0x542, 0x543, 0x544, 0x545, 0x546, 0x547,
     0x548, 0x549, 0x54a, 0x54b, 0x54c, 0x54d, 0x54e, 0x54f,
     0x550, 0x551, 0x552, 0x553, 0x554, 0x555, 0x556, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 case_1E[] = {
     0x1e01, 0x1e00, 0x1e03, 0x1e02, 0x1e05, 0x1e04, 0x1e07, 0x1e06,
     0x1e09, 0x1e08, 0x1e0b, 0x1e0a, 0x1e0d, 0x1e0c, 0x1e0f, 0x1e0e,
     0x1e11, 0x1e10, 0x1e13, 0x1e12, 0x1e15, 0x1e14, 0x1e17, 0x1e16,
     0x1e19, 0x1e18, 0x1e1b, 0x1e1a, 0x1e1d, 0x1e1c, 0x1e1f, 0x1e1e,
     0x1e21, 0x1e20, 0x1e23, 0x1e22, 0x1e25, 0x1e24, 0x1e27, 0x1e26,
     0x1e29, 0x1e28, 0x1e2b, 0x1e2a, 0x1e2d, 0x1e2c, 0x1e2f, 0x1e2e,
     0x1e31, 0x1e30, 0x1e33, 0x1e32, 0x1e35, 0x1e34, 0x1e37, 0x1e36,
     0x1e39, 0x1e38, 0x1e3b, 0x1e3a, 0x1e3d, 0x1e3c, 0x1e3f, 0x1e3e,
     0x1e41, 0x1e40, 0x1e43, 0x1e42, 0x1e45, 0x1e44, 0x1e47, 0x1e46,
     0x1e49, 0x1e48, 0x1e4b, 0x1e4a, 0x1e4d, 0x1e4c, 0x1e4f, 0x1e4e,
     0x1e51, 0x1e50, 0x1e53, 0x1e52, 0x1e55, 0x1e54, 0x1e57, 0x1e56,
     0x1e59, 0x1e58, 0x1e5b, 0x1e5a, 0x1e5d, 0x1e5c, 0x1e5f, 0x1e5e,
     0x1e61, 0x1e60, 0x1e63, 0x1e62, 0x1e65, 0x1e64, 0x1e67, 0x1e66,
     0x1e69, 0x1e68, 0x1e6b, 0x1e6a, 0x1e6d, 0x1e6c, 0x1e6f, 0x1e6e,
     0x1e71, 0x1e70, 0x1e73, 0x1e72, 0x1e75, 0x1e74, 0x1e77, 0x1e76,
     0x1e79, 0x1e78, 0x1e7b, 0x1e7a, 0x1e7d, 0x1e7c, 0x1e7f, 0x1e7e,
     0x1e81, 0x1e80, 0x1e83, 0x1e82, 0x1e85, 0x1e84, 0x1e87, 0x1e86,
     0x1e89, 0x1e88, 0x1e8b, 0x1e8a, 0x1e8d, 0x1e8c, 0x1e8f, 0x1e8e,
     0x1e91, 0x1e90, 0x1e93, 0x1e92, 0x1e95, 0x1e94, 0, 0,
     0, 0, 0, 0x1e60, 0, 0, 0, 0,
     0x1ea1, 0x1ea0, 0x1ea3, 0x1ea2, 0x1ea5, 0x1ea4, 0x1ea7, 0x1ea6,
     0x1ea9, 0x1ea8, 0x1eab, 0x1eaa, 0x1ead, 0x1eac, 0x1eaf, 0x1eae,
     0x1eb1, 0x1eb0, 0x1eb3, 0x1eb2, 0x1eb5, 0x1eb4, 0x1eb7, 0x1eb6,
     0x1eb9, 0x1eb8, 0x1ebb, 0x1eba, 0x1ebd, 0x1ebc, 0x1ebf, 0x1ebe,
     0x1ec1, 0x1ec0, 0x1ec3, 0x1ec2, 0x1ec5, 0x1ec4, 0x1ec7, 0x1ec6,
     0x1ec9, 0x1ec8, 0x1ecb, 0x1eca, 0x1ecd, 0x1ecc, 0x1ecf, 0x1ece,
     0x1ed1, 0x1ed0, 0x1ed3, 0x1ed2, 0x1ed5, 0x1ed4, 0x1ed7, 0x1ed6,
     0x1ed9, 0x1ed8, 0x1edb, 0x1eda, 0x1edd, 0x1edc, 0x1edf, 0x1ede,
     0x1ee1, 0x1ee0, 0x1ee3, 0x1ee2, 0x1ee5, 0x1ee4, 0x1ee7, 0x1ee6,
     0x1ee9, 0x1ee8, 0x1eeb, 0x1eea, 0x1eed, 0x1eec, 0x1eef, 0x1eee,
     0x1ef1, 0x1ef0, 0x1ef3, 0x1ef2, 0x1ef5, 0x1ef4, 0x1ef7, 0x1ef6,
     0x1ef9, 0x1ef8, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 case_1F[] = {
     0x1f08, 0x1f09, 0x1f0a, 0x1f0b, 0x1f0c, 0x1f0d, 0x1f0e, 0x1f0f,
     0x1f00, 0x1f01, 0x1f02, 0x1f03, 0x1f04, 0x1f05, 0x1f06, 0x1f07,
     0x1f18, 0x1f19, 0x1f1a, 0x1f1b, 0x1f1c, 0x1f1d, 0, 0,
     0x1f10, 0x1f11, 0x1f12, 0x1f13, 0x1f14, 0x1f15, 0, 0,
     0x1f28, 0x1f29, 0x1f2a, 0x1f2b, 0x1f2c, 0x1f2d, 0x1f2e, 0x1f2f,
     0x1f20, 0x1f21, 0x1f22, 0x1f23, 0x1f24, 0x1f25, 0x1f26, 0x1f27,
     0x1f38, 0x1f39, 0x1f3a, 0x1f3b, 0x1f3c, 0x1f3d, 0x1f3e, 0x1f3f,
     0x1f30, 0x1f31, 0x1f32, 0x1f33, 0x1f34, 0x1f35, 0x1f36, 0x1f37,
     0x1f48, 0x1f49, 0x1f4a, 0x1f4b, 0x1f4c, 0x1f4d, 0, 0,
     0x1f40, 0x1f41, 0x1f42, 0x1f43, 0x1f44, 0x1f45, 0, 0,
     0, 0x1f59, 0, 0x1f5b, 0, 0x1f5d, 0, 0x1f5f,
     0, 0x1f51, 0, 0x1f53, 0, 0x1f55, 0, 0x1f57,
     0x1f68, 0x1f69, 0x1f6a, 0x1f6b, 0x1f6c, 0x1f6d, 0x1f6e, 0x1f6f,
     0x1f60, 0x1f61, 0x1f62, 0x1f63, 0x1f64, 0x1f65, 0x1f66, 0x1f67,
     0x1fba, 0x1fbb, 0x1fc8, 0x1fc9, 0x1fca, 0x1fcb, 0x1fda, 0x1fdb,
     0x1ff8, 0x1ff9, 0x1fea, 0x1feb, 0x1ffa, 0x1ffb, 0, 0,
     0x1f88, 0x1f89, 0x1f8a, 0x1f8b, 0x1f8c, 0x1f8d, 0x1f8e, 0x1f8f,
     0x1f80, 0x1f81, 0x1f82, 0x1f83, 0x1f84, 0x1f85, 0x1f86, 0x1f87,
     0x1f98, 0x1f99, 0x1f9a, 0x1f9b, 0x1f9c, 0x1f9d, 0x1f9e, 0x1f9f,
     0x1f90, 0x1f91, 0x1f92, 0x1f93, 0x1f94, 0x1f95, 0x1f96, 0x1f97,
     0x1fa8, 0x1fa9, 0x1faa, 0x1fab, 0x1fac, 0x1fad, 0x1fae, 0x1faf,
     0x1fa0, 0x1fa1, 0x1fa2, 0x1fa3, 0x1fa4, 0x1fa5, 0x1fa6, 0x1fa7,
     0x1fb8, 0x1fb9, 0, 0x1fbc, 0, 0, 0, 0,
     0x1fb0, 0x1fb1, 0x1f70, 0x1f71, 0x1fb3, 0, 0x399, 0,
     0, 0, 0, 0x1fcc, 0, 0, 0, 0,
     0x1f72, 0x1f73, 0x1f74, 0x1f75, 0x1fc3, 0, 0, 0,
     0x1fd8, 0x1fd9, 0, 0, 0, 0, 0, 0,
     0x1fd0, 0x1fd1, 0x1f76, 0x1f77, 0, 0, 0, 0,
     0x1fe8, 0x1fe9, 0, 0, 0, 0x1fec, 0, 0,
     0x1fe0, 0x1fe1, 0x1f7a, 0x1f7b, 0x1fe5, 0, 0, 0,
     0, 0, 0, 0x1ffc, 0, 0, 0, 0,
     0x1f78, 0x1f79, 0x1f7c, 0x1f7d, 0x1ff3, 0, 0, 0,
 };
 
 static const Q_UINT16 case_21[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0x3c9, 0,
     0, 0, 0x6b, 0xe5, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177,
     0x2178, 0x2179, 0x217a, 0x217b, 0x217c, 0x217d, 0x217e, 0x217f,
     0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167,
     0x2168, 0x2169, 0x216a, 0x216b, 0x216c, 0x216d, 0x216e, 0x216f,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 case_24[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0x24d0, 0x24d1,
     0x24d2, 0x24d3, 0x24d4, 0x24d5, 0x24d6, 0x24d7, 0x24d8, 0x24d9,
     0x24da, 0x24db, 0x24dc, 0x24dd, 0x24de, 0x24df, 0x24e0, 0x24e1,
     0x24e2, 0x24e3, 0x24e4, 0x24e5, 0x24e6, 0x24e7, 0x24e8, 0x24e9,
     0x24b6, 0x24b7, 0x24b8, 0x24b9, 0x24ba, 0x24bb, 0x24bc, 0x24bd,
     0x24be, 0x24bf, 0x24c0, 0x24c1, 0x24c2, 0x24c3, 0x24c4, 0x24c5,
     0x24c6, 0x24c7, 0x24c8, 0x24c9, 0x24ca, 0x24cb, 0x24cc, 0x24cd,
     0x24ce, 0x24cf, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 case_FF[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0xff41, 0xff42, 0xff43, 0xff44, 0xff45, 0xff46, 0xff47,
     0xff48, 0xff49, 0xff4a, 0xff4b, 0xff4c, 0xff4d, 0xff4e, 0xff4f,
     0xff50, 0xff51, 0xff52, 0xff53, 0xff54, 0xff55, 0xff56, 0xff57,
     0xff58, 0xff59, 0xff5a, 0, 0, 0, 0, 0,
     0, 0xff21, 0xff22, 0xff23, 0xff24, 0xff25, 0xff26, 0xff27,
     0xff28, 0xff29, 0xff2a, 0xff2b, 0xff2c, 0xff2d, 0xff2e, 0xff2f,
     0xff30, 0xff31, 0xff32, 0xff33, 0xff34, 0xff35, 0xff36, 0xff37,
     0xff38, 0xff39, 0xff3a, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const Q_UINT16 * const case_info[256] = {
     case_00, case_01, case_02, case_03, case_04, case_05, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, case_1E, case_1F,
     0, case_21, 0, 0, case_24, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, case_FF,
 };
 // 39162 bytes
 
 static const Q_INT8 num_00[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     0, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, 2, 3, -1, -1, -1, -1,
     -1, 1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_06[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     0, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     0, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_09[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, 0, 1,
     2, 3, 4, 5, 6, 7, 8, 9,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, 0, 1,
     2, 3, 4, 5, 6, 7, 8, 9,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_0B[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, 0, 1,
     2, 3, 4, 5, 6, 7, 8, 9,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, 1,
     2, 3, 4, 5, 6, 7, 8, 9,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_0D[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, 0, 1,
     2, 3, 4, 5, 6, 7, 8, 9,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_0E[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     0, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     0, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_0F[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     0, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_10[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     0, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_13[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_17[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     0, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_18[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     0, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_20[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     0, -1, -1, -1, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     0, 1, 2, 3, 4, 5, 6, 7,
     8, 9, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 num_24[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     1, 2, 3, 4, 5, 6, 7, 8,
     9, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, 1, 2, 3, 4,
     5, 6, 7, 8, 9, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     1, 2, 3, 4, 5, 6, 7, 8,
     9, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, 0, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, 1, 2, 3,
     4, 5, 6, 7, 8, 9, -1, -1,
 };
 
 static const Q_INT8 num_27[] = {
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, 1, 2,
     3, 4, 5, 6, 7, 8, 9, -1,
     1, 2, 3, 4, 5, 6, 7, 8,
     9, -1, 1, 2, 3, 4, 5, 6,
     7, 8, 9, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 static const Q_INT8 * const decimal_info[256] = {
     num_00, 0, 0, 0, 0, 0, num_06, 0,
     0, num_09, num_09, num_0B, num_09, num_0D, num_0E, num_0F,
     num_10, 0, 0, num_13, 0, 0, 0, num_17,
     num_18, 0, 0, 0, 0, 0, 0, 0,
     num_20, 0, 0, 0, num_24, 0, 0, num_27,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, num_18,
 };
 // 47354 bytes
 
 // END OF GENERATED DATA
 
 #endif
 
 static inline QChar::Category category( const QChar &c )
 {
 #ifndef QT_NO_UNICODETABLES
     return (QChar::Category)(unicode_info[c.row()][c.cell()]);
 #else
 // ### just ASCII
     if ( c.unicode() < 0x100 ) {
 	return (QChar::Category)(ui_00[c.unicode()]);
     }
     return QChar::Letter_Uppercase; //#######
 #endif
 }
 
 static inline QChar lower( const QChar &c )
 {
 #ifndef QT_NO_UNICODETABLES
     uchar row = c.row();
     uchar cell = c.cell();
     if ( unicode_info[row][cell] != QChar::Letter_Uppercase )
 	return c;
     Q_UINT16 lower = *( case_info[row] + cell );
     if ( lower == 0 )
 	return c;
     return lower;
 #else
     if ( c.row() )
 	return c;
     else
 	return QChar( tolower((uchar) c.latin1()) );
 #endif
 }
 
 static inline QChar upper( const QChar &c )
 {
 #ifndef QT_NO_UNICODETABLES
     uchar row = c.row();
     uchar cell = c.cell();
     if ( unicode_info[row][cell] != QChar::Letter_Lowercase )
 	return c;
     Q_UINT16 upper = *(case_info[row]+cell);
     if ( upper == 0 )
 	return c;
     return upper;
 #else
     if ( c.row() )
 	return c;
     else
 	return QChar( toupper((uchar) c.latin1()) );
 #endif
 }
 
 static inline QChar::Direction direction( const QChar &c )
 {
 #ifndef QT_NO_UNICODETABLES
     const Q_UINT8 *rowp = direction_info[c.row()];
     if(!rowp) return QChar::DirL;
     return (QChar::Direction) ( *(rowp+c.cell()) & 0x1f );
 #else
+    Q_UNUSED(c);
     return QChar::DirL;
 #endif
 }
 
 static inline bool mirrored( const QChar &c )
 {
 #ifndef QT_NO_UNICODETABLES
     const Q_UINT8 *rowp = direction_info[c.row()];
     if ( !rowp )
 	return FALSE;
     return *(rowp+c.cell())>128;
 #else
+    Q_UNUSED(c);
     return FALSE;
 #endif
 }
 
 #ifndef QT_NO_UNICODETABLES
 static const Q_UINT16 symmetricPairs[] = {
     0x0028, 0x0029, 0x003C, 0x003E, 0x005B, 0x005D, 0x007B, 0x007D,
     0x00AB, 0x00BB, 0x2039, 0x203A, 0x2045, 0x2046, 0x207D, 0x207E,
     0x208D, 0x208E, 0x2208, 0x220B, 0x2209, 0x220C, 0x220A, 0x220D,
     0x2215, 0x29F5, 0x223C, 0x223D, 0x2243, 0x22CD, 0x2252, 0x2253,
     0x2254, 0x2255, 0x2264, 0x2265, 0x2266, 0x2267, 0x2268, 0x2269,
     0x226A, 0x226B, 0x226E, 0x226F, 0x2270, 0x2271, 0x2272, 0x2273,
     0x2274, 0x2275, 0x2276, 0x2277, 0x2278, 0x2279, 0x227A, 0x227B,
     0x227C, 0x227D, 0x227E, 0x227F, 0x2280, 0x2281, 0x2282, 0x2283,
     0x2284, 0x2285, 0x2286, 0x2287, 0x2288, 0x2289, 0x228A, 0x228B,
     0x228F, 0x2290, 0x2291, 0x2292, 0x2298, 0x29B8, 0x22A2, 0x22A3,
     0x22A6, 0x2ADE, 0x22A8, 0x2AE4, 0x22A9, 0x2AE3, 0x22AB, 0x2AE5,
     0x22B0, 0x22B1, 0x22B2, 0x22B3, 0x22B4, 0x22B5, 0x22B6, 0x22B7,
     0x22C9, 0x22CA, 0x22CB, 0x22CC, 0x22D0, 0x22D1, 0x22D6, 0x22D7,
     0x22D8, 0x22D9, 0x22DA, 0x22DB, 0x22DC, 0x22DD, 0x22DE, 0x22DF,
     0x22E0, 0x22E1, 0x22E2, 0x22E3, 0x22E4, 0x22E5, 0x22E6, 0x22E7,
     0x22E8, 0x22E9, 0x22EA, 0x22EB, 0x22EC, 0x22ED, 0x22F0, 0x22F1,
     0x22F2, 0x22FA, 0x22F3, 0x22FB, 0x22F4, 0x22FC, 0x22F6, 0x22FD,
     0x22F7, 0x22FE, 0x2308, 0x2309, 0x230A, 0x230B, 0x2329, 0x232A,
     0x2768, 0x2769, 0x276A, 0x276B, 0x276C, 0x276D, 0x276E, 0x276F,
     0x2770, 0x2771, 0x2772, 0x2773, 0x2774, 0x2775, 0x27D5, 0x27D6,
     0x27DD, 0x27DE, 0x27E2, 0x27E3, 0x27E4, 0x27E5, 0x27E6, 0x27E7,
     0x27E8, 0x27E9, 0x27EA, 0x27EB, 0x2983, 0x2984, 0x2985, 0x2986,
     0x2987, 0x2988, 0x2989, 0x298A, 0x298B, 0x298C, 0x298D, 0x2990,
     0x298E, 0x298F, 0x2991, 0x2992, 0x2993, 0x2994, 0x2995, 0x2996,
     0x2997, 0x2998, 0x29C0, 0x29C1, 0x29C4, 0x29C5, 0x29CF, 0x29D0,
     0x29D1, 0x29D2, 0x29D4, 0x29D5, 0x29D8, 0x29D9, 0x29DA, 0x29DB,
     0x29F8, 0x29F9, 0x29FC, 0x29FD, 0x2A2B, 0x2A2C, 0x2A34, 0x2A35,
     0x2A3C, 0x2A3D, 0x2A64, 0x2A65, 0x2A79, 0x2A7A, 0x2A7D, 0x2A7E,
     0x2A7F, 0x2A80, 0x2A81, 0x2A82, 0x2A83, 0x2A84, 0x2A8B, 0x2A8C,
     0x2A91, 0x2A92, 0x2A93, 0x2A94, 0x2A95, 0x2A96, 0x2A97, 0x2A98,
     0x2A99, 0x2A9A, 0x2A9B, 0x2A9C, 0x2AA1, 0x2AA2, 0x2AA6, 0x2AA7,
     0x2AA8, 0x2AA9, 0x2AAA, 0x2AAB, 0x2AAC, 0x2AAD, 0x2AAF, 0x2AB0,
     0x2AB3, 0x2AB4, 0x2ABB, 0x2ABC, 0x2ABD, 0x2ABE, 0x2ABF, 0x2AC0,
     0x2AC1, 0x2AC2, 0x2AC3, 0x2AC4, 0x2AC5, 0x2AC6, 0x2ACD, 0x2ACE,
     0x2ACF, 0x2AD0, 0x2AD1, 0x2AD2, 0x2AD3, 0x2AD4, 0x2AD5, 0x2AD6,
     0x2AEC, 0x2AED, 0x2AF7, 0x2AF8, 0x2AF9, 0x2AFA, 0x3008, 0x3009,
     0x300A, 0x300B, 0x300C, 0x300D, 0x300E, 0x300F, 0x3010, 0x3011,
     0x3014, 0x3015, 0x3016, 0x3017, 0x3018, 0x3019, 0x301A, 0x301B,
     0xFF08, 0xFF09, 0xFF1C, 0xFF1E, 0xFF3B, 0xFF3D, 0xFF5B, 0xFF5D,
     0xFF5F, 0xFF60, 0xFF62, 0xFF63,
 };
 
 // ### shouldn't this be const?
 static const int symmetricPairsSize =
    sizeof(symmetricPairs)/sizeof(symmetricPairs[0]);
 
 /*
  * ----------------------------------------------------------------------
  * End of unicode tables
  * ----------------------------------------------------------------------
  */
 
 #endif
 
 static int ucstrcmp( const QString &as, const QString &bs )
 {
     const QChar *a = as.unicode();
     const QChar *b = bs.unicode();
     if ( a == b )
 	return 0;
     if ( a == 0 )
 	return 1;
     if ( b == 0 )
 	return -1;
     int l=QMIN(as.length(),bs.length());
     while ( l-- && *a == *b )
 	a++,b++;
     if ( l==-1 )
 	return ( as.length()-bs.length() );
     return a->unicode() - b->unicode();
 }
 
 static int ucstrncmp( const QChar *a, const QChar *b, int l )
 {
     while ( l-- && *a == *b )
 	a++,b++;
     if ( l==-1 )
 	return 0;
     return a->unicode() - b->unicode();
 }
 
 static int ucstrnicmp( const QChar *a, const QChar *b, int l )
 {
     while ( l-- && ::lower( *a ) == ::lower( *b ) )
 	a++,b++;
     if ( l==-1 )
 	return 0;
     return ::lower( *a ).unicode() - ::lower( *b ).unicode();
 }
 
 static uint computeNewMax( uint len )
 {
     uint newMax = 4;
     while ( newMax < len )
 	newMax *= 2;
-    // try to spare some memory
+    // try to save some memory
     if ( newMax >= 1024 * 1024 && len <= newMax - (newMax >> 2) )
 	newMax -= newMax >> 2;
     return newMax;
 }
 
 /*!
     \class QCharRef qstring.h
     \reentrant
     \brief The QCharRef class is a helper class for QString.
 
     \ingroup text
 
     When you get an object of type QCharRef, if you can assign to it,
     the assignment will apply to the character in the string from
     which you got the reference. That is its whole purpose in life.
     The QCharRef becomes invalid once modifications are made to the
     string: if you want to keep the character, copy it into a QChar.
 
     Most of the QChar member functions also exist in QCharRef.
     However, they are not explicitly documented here.
 
     \sa QString::operator[]() QString::at() QChar
 */
 
 /*!
     \class QChar qstring.h
     \reentrant
     \brief The QChar class provides a lightweight Unicode character.
 
     \ingroup text
 
     Unicode characters are (so far) 16-bit entities without any markup
     or structure. This class represents such an entity. It is
     lightweight, so it can be used everywhere. Most compilers treat it
     like a "short int".  (In a few years it may be necessary to make
     QChar 32-bit when more than 65536 Unicode code points have been
     defined and come into use.)
 
     QChar provides a full complement of testing/classification
     functions, converting to and from other formats, converting from
     composed to decomposed Unicode, and trying to compare and
     case-convert if you ask it to.
 
     The classification functions include functions like those in
     ctype.h, but operating on the full range of Unicode characters.
     They all return TRUE if the character is a certain type of
     character; otherwise they return FALSE. These classification
     functions are isNull() (returns TRUE if the character is U+0000),
     isPrint() (TRUE if the character is any sort of printable
     character, including whitespace), isPunct() (any sort of
     punctation), isMark() (Unicode Mark), isLetter (a letter),
     isNumber() (any sort of numeric character), isLetterOrNumber(),
     and isDigit() (decimal digits). All of these are wrappers around
     category() which return the Unicode-defined category of each
     character.
 
     QChar further provides direction(), which indicates the "natural"
     writing direction of this character. The joining() function
     indicates how the character joins with its neighbors (needed
     mostly for Arabic) and finally mirrored(), which indicates whether
     the character needs to be mirrored when it is printed in its
     "unnatural" writing direction.
 
     Composed Unicode characters (like &aring;) can be converted to
     decomposed Unicode ("a" followed by "ring above") by using
     decomposition().
 
     In Unicode, comparison is not necessarily possible and case
     conversion is very difficult at best. Unicode, covering the
     "entire" world, also includes most of the world's case and sorting
     problems. Qt tries, but not very hard: operator==() and friends
     will do comparison based purely on the numeric Unicode value (code
     point) of the characters, and upper() and lower() will do case
     changes when the character has a well-defined upper/lower-case
     equivalent. There is no provision for locale-dependent case
     folding rules or comparison; these functions are meant to be fast
     so they can be used unambiguously in data structures. (See
     QString::localeAwareCompare() though.)
 
     The conversion functions include unicode() (to a scalar), latin1()
     (to scalar, but converts all non-Latin1 characters to 0), row()
     (gives the Unicode row), cell() (gives the Unicode cell),
     digitValue() (gives the integer value of any of the numerous digit
     characters), and a host of constructors.
 
     More information can be found in the document \link unicode.html
     About Unicode. \endlink
 
     \sa QString QCharRef
 */
 
 /*!
     \enum QChar::Category
 
     This enum maps the Unicode character categories.
 
     The following characters are normative in Unicode:
 
     \value Mark_NonSpacing  Unicode class name Mn
 
     \value Mark_SpacingCombining  Unicode class name Mc
 
     \value Mark_Enclosing  Unicode class name Me
 
     \value Number_DecimalDigit  Unicode class name Nd
 
     \value Number_Letter  Unicode class name Nl
 
     \value Number_Other  Unicode class name No
 
     \value Separator_Space  Unicode class name Zs
 
     \value Separator_Line  Unicode class name Zl
 
     \value Separator_Paragraph  Unicode class name Zp
 
     \value Other_Control  Unicode class name Cc
 
     \value Other_Format  Unicode class name Cf
 
     \value Other_Surrogate  Unicode class name Cs
 
     \value Other_PrivateUse  Unicode class name Co
 
     \value Other_NotAssigned  Unicode class name Cn
 
 
     The following categories are informative in Unicode:
 
     \value Letter_Uppercase  Unicode class name Lu
 
     \value Letter_Lowercase  Unicode class name Ll
 
     \value Letter_Titlecase  Unicode class name Lt
 
     \value Letter_Modifier  Unicode class name Lm
 
     \value Letter_Other Unicode class name Lo
 
     \value Punctuation_Connector  Unicode class name Pc
 
     \value Punctuation_Dash  Unicode class name Pd
 
     \value Punctuation_Open  Unicode class name Ps
 
     \value Punctuation_Close  Unicode class name Pe
 
     \value Punctuation_InitialQuote  Unicode class name Pi
 
     \value Punctuation_FinalQuote  Unicode class name Pf
 
     \value Punctuation_Other  Unicode class name Po
 
     \value Symbol_Math  Unicode class name Sm
 
     \value Symbol_Currency  Unicode class name Sc
 
     \value Symbol_Modifier  Unicode class name Sk
 
     \value Symbol_Other  Unicode class name So
 
 
     There are two categories that are specific to Qt:
 
     \value NoCategory  used when Qt is dazed and confused and cannot
     make sense of anything.
 
     \value Punctuation_Dask  old typo alias for Punctuation_Dash
 
 */
 
 /*!
     \enum QChar::Direction
 
     This enum type defines the Unicode direction attributes. See \link
     http://www.unicode.org/ the Unicode Standard\endlink for a
     description of the values.
 
     In order to conform to C/C++ naming conventions "Dir" is prepended
     to the codes used in the Unicode Standard.
 */
 
 /*!
     \enum QChar::Decomposition
 
     This enum type defines the Unicode decomposition attributes. See
     \link http://www.unicode.org/ the Unicode Standard\endlink for a
     description of the values.
 */
 
 /*!
     \enum QChar::Joining
 
     This enum type defines the Unicode joining attributes. See \link
     http://www.unicode.org/ the Unicode Standard\endlink for a
     description of the values.
 */
 
 /*!
     \enum QChar::CombiningClass
 
     This enum type defines names for some of the Unicode combining
     classes. See \link http://www.unicode.org/ the Unicode
     Standard\endlink for a description of the values.
 */
 
 /*!
     \fn void QChar::setCell( uchar cell )
     \internal
 */
 
 /*!
     \fn void QChar::setRow( uchar row )
     \internal
 */
 
 
 /*!
     \fn QChar::QChar()
 
     Constructs a null QChar (one that isNull()).
 */
 
 
 /*!
     \fn QChar::QChar( char c )
 
     Constructs a QChar corresponding to ASCII/Latin1 character \a c.
 */
 
 
 /*!
     \fn QChar::QChar( uchar c )
 
     Constructs a QChar corresponding to ASCII/Latin1 character \a c.
 */
 
 
 /*!
     \fn QChar::QChar( uchar c, uchar r )
 
     Constructs a QChar for Unicode cell \a c in row \a r.
 */
 
 
 /*!
     \fn QChar::QChar( const QChar& c )
 
     Constructs a copy of \a c. This is a deep copy, if such a
     lightweight object can be said to have deep copies.
 */
 
 
 /*!
     \fn QChar::QChar( ushort rc )
 
     Constructs a QChar for the character with Unicode code point \a rc.
 */
 
 
 /*!
     \fn QChar::QChar( short rc )
 
     Constructs a QChar for the character with Unicode code point \a rc.
 */
 
 
 /*!
     \fn QChar::QChar( uint rc )
 
     Constructs a QChar for the character with Unicode code point \a rc.
 */
 
 
 /*!
     \fn QChar::QChar( int rc )
 
     Constructs a QChar for the character with Unicode code point \a rc.
 */
 
 
 /*!
     \fn bool  QChar::networkOrdered ()
 
     \obsolete
 
     Returns TRUE if this character is in network byte order (MSB
     first); otherwise returns FALSE. This is platform dependent.
 */
 
 
 /*!
     \fn bool QChar::isNull() const
 
     Returns TRUE if the character is the Unicode character 0x0000,
     i.e. ASCII NUL; otherwise returns FALSE.
 */
 
 /*!
     \fn uchar QChar::cell () const
 
     Returns the cell (least significant byte) of the Unicode
     character.
 */
 
 /*!
     \fn uchar QChar::row () const
 
     Returns the row (most significant byte) of the Unicode character.
 */
 
 /*!
     Returns TRUE if the character is a printable character; otherwise
     returns FALSE. This is any character not of category Cc or Cn.
 
     Note that this gives no indication of whether the character is
     available in a particular \link QFont font\endlink.
 */
 bool QChar::isPrint() const
 {
     Category c = ::category( *this );
     return !(c == Other_Control || c == Other_NotAssigned);
 }
 
 /*!
     Returns TRUE if the character is a separator character
     (Separator_* categories); otherwise returns FALSE.
 */
 bool QChar::isSpace() const
 {
     if( ucs >= 9 && ucs <=13 ) return TRUE;
     Category c = ::category( *this );
     return c >= Separator_Space && c <= Separator_Paragraph;
 }
 
 /*!
     Returns TRUE if the character is a mark (Mark_* categories);
     otherwise returns FALSE.
 */
 bool QChar::isMark() const
 {
     Category c = ::category( *this );
     return c >= Mark_NonSpacing && c <= Mark_Enclosing;
 }
 
 /*!
     Returns TRUE if the character is a punctuation mark (Punctuation_*
     categories); otherwise returns FALSE.
 */
 bool QChar::isPunct() const
 {
     Category c = ::category( *this );
     return (c >= Punctuation_Connector && c <= Punctuation_Other);
 }
 
 /*!
     Returns TRUE if the character is a letter (Letter_* categories);
     otherwise returns FALSE.
 */
 bool QChar::isLetter() const
 {
     Category c = ::category( *this );
     return (c >= Letter_Uppercase && c <= Letter_Other);
 }
 
 /*!
     Returns TRUE if the character is a number (of any sort - Number_*
     categories); otherwise returns FALSE.
 
     \sa isDigit()
 */
 bool QChar::isNumber() const
 {
     Category c = ::category( *this );
     return c >= Number_DecimalDigit && c <= Number_Other;
 }
 
 /*!
     Returns TRUE if the character is a letter or number (Letter_* or
     Number_* categories); otherwise returns FALSE.
 */
 bool QChar::isLetterOrNumber() const
 {
     Category c = ::category( *this );
     return (c >= Letter_Uppercase && c <= Letter_Other)
 	|| (c >= Number_DecimalDigit && c <= Number_Other);
 }
 
 
 /*!
     Returns TRUE if the character is a decimal digit
     (Number_DecimalDigit); otherwise returns FALSE.
 */
 bool QChar::isDigit() const
 {
     return (::category( *this ) == Number_DecimalDigit);
 }
 
 
 /*!
     Returns TRUE if the character is a symbol (Symbol_* categories);
     otherwise returns FALSE.
 */
 bool QChar::isSymbol() const
 {
     Category c = ::category( *this );
     return c >= Symbol_Math && c <= Symbol_Other;
 }
 
 /*!
     Returns the numeric value of the digit, or -1 if the character is
     not a digit.
 */
 int QChar::digitValue() const
 {
 #ifndef QT_NO_UNICODETABLES
     const Q_INT8 *dec_row = decimal_info[row()];
     if( !dec_row )
 	return -1;
     return dec_row[cell()];
 #else
     // ##### just latin1
     if ( ucs < '0' || ucs > '9' )
 	return -1;
     else
 	return ucs - '0';
 #endif
 }
 
 /*!
     Returns the character category.
 
     \sa Category
 */
 QChar::Category QChar::category() const
 {
      return ::category( *this );
 }
 
 /*!
     Returns the character's direction.
 
     \sa Direction
 */
 QChar::Direction QChar::direction() const
 {
      return ::direction( *this );
 }
 
 /*!
     \warning This function is not supported (it may change to use
     Unicode character classes).
 
     Returns information about the joining properties of the character
     (needed for example, for Arabic).
 */
 QChar::Joining QChar::joining() const
 {
 #ifndef QT_NO_UNICODETABLES
     const Q_UINT8 *rowp = direction_info[row()];
     if ( !rowp )
 	return QChar::OtherJoining;
     return (Joining) ((*(rowp+cell()) >> 5) &0x3);
 #else
     return OtherJoining;
 #endif
 }
 
 
 /*!
     Returns TRUE if the character is a mirrored character (one that
     should be reversed if the text direction is reversed); otherwise
     returns FALSE.
 */
 bool QChar::mirrored() const
 {
     return ::mirrored( *this );
 }
 
 /*!
     Returns the mirrored character if this character is a mirrored
     character, otherwise returns the character itself.
 */
 QChar QChar::mirroredChar() const
 {
 #ifndef QT_NO_UNICODETABLES
     if(!::mirrored( *this ))
 	return *this;
 
     int i;
     int c = unicode();
     for (i = 0; i < symmetricPairsSize; i ++) {
 	if (symmetricPairs[i] == c)
 	  return symmetricPairs[(i%2) ? (i-1) : (i+1)];
     }
 #endif
     return *this;
 }
 
 #ifndef QT_NO_UNICODETABLES
 // ### REMOVE ME 4.0
 static QString shared_decomp;
 #endif
 /*!
     \nonreentrant
 
     Decomposes a character into its parts. Returns QString::null if no
     decomposition exists.
 */
 const QString &QChar::decomposition() const
 {
 #ifndef QT_NO_UNICODETABLES
     const Q_UINT16 *r = decomposition_info[row()];
     if(!r) return QString::null;
 
     Q_UINT16 pos = r[cell()];
     if(!pos) return QString::null;
     pos+=2;
 
     QString s;
     Q_UINT16 c;
     while((c = decomposition_map[pos++]) != 0) s += QChar(c);
     // ### In 4.0, return s, and not shared_decomp.  shared_decomp
     // prevents this function from being reentrant.
     shared_decomp = s;
     return shared_decomp;
 #else
     return QString::null;
 #endif
 }
 
 /*!
     Returns the tag defining the composition of the character. Returns
     QChar::Single if no decomposition exists.
 */
 QChar::Decomposition QChar::decompositionTag() const
 {
 #ifndef QT_NO_UNICODETABLES
     const Q_UINT16 *r = decomposition_info[row()];
     if(!r) return QChar::Single;
 
     Q_UINT16 pos = r[cell()];
     if(!pos) return QChar::Single;
 
     return (QChar::Decomposition) decomposition_map[pos];
 #else
     return Single; // ########### FIX eg. just latin1
 #endif
 }
 
 /*!
     Returns the combining class for the character as defined in the
     Unicode standard. This is mainly useful as a positioning hint for
     marks attached to a base character.
 
     The Qt text rendering engine uses this information to correctly
     position non spacing marks around a base character.
 */
 unsigned char QChar::combiningClass() const
 {
 #ifndef QT_NO_UNICODETABLES
     const Q_UINT8 *rowp = combining_info[row()];
     if ( !rowp )
 	return 0;
     return *(rowp+cell());
 #else
     return 0;
 #endif
 }
 
 
 /*!
     Returns the lowercase equivalent if the character is uppercase;
     otherwise returns the character itself.
 */
 QChar QChar::lower() const
 {
      return ::lower( *this );
 }
 
 /*!
     Returns the uppercase equivalent if the character is lowercase;
     otherwise returns the character itself.
 */
 QChar QChar::upper() const
 {
      return ::upper( *this );
 }
 
 /*!
     \fn QChar::operator char() const
 
     Returns the Latin1 character equivalent to the QChar, or 0. This
     is mainly useful for non-internationalized software.
 
     \sa unicode()
 */
 
 /*!
     \fn ushort QChar::unicode() const
 
     Returns the numeric Unicode value equal to the QChar. Normally,
     you should use QChar objects as they are equivalent, but for some
     low-level tasks (e.g. indexing into an array of Unicode
     information), this function is useful.
 */
 
 /*!
     \fn ushort & QChar::unicode()
 
     \overload
 
     Returns a reference to the numeric Unicode value equal to the
     QChar.
 */
 
 /*****************************************************************************
   Documentation of QChar related functions
  *****************************************************************************/
 
 /*!
     \fn bool operator==( QChar c1, QChar c2 )
 
     \relates QChar
 
     Returns TRUE if \a c1 and \a c2 are the same Unicode character;
     otherwise returns FALSE.
 */
 
 /*!
     \fn bool operator==( char ch, QChar c )
 
     \overload
     \relates QChar
 
     Returns TRUE if \a c is the ASCII/Latin1 character \a ch;
     otherwise returns FALSE.
 */
 
 /*!
     \fn bool operator==( QChar c, char ch )
 
     \overload
     \relates QChar
 
     Returns TRUE if \a c is the ASCII/Latin1 character \a ch;
     otherwise returns FALSE.
 */
 
 /*!
     \fn int operator!=( QChar c1, QChar c2 )
 
     \relates QChar
 
     Returns TRUE if \a c1 and \a c2 are not the same Unicode
     character; otherwise returns FALSE.
 */
 
 /*!
     \fn int operator!=( char ch, QChar c )
 
     \overload
     \relates QChar
 
     Returns TRUE if \a c is not the ASCII/Latin1 character \a ch;
     otherwise returns FALSE.
 */
 
 /*!
     \fn int operator!=( QChar c, char ch )
 
     \overload
     \relates QChar
 
     Returns TRUE if \a c is not the ASCII/Latin1 character \a ch;
     otherwise returns FALSE.
 */
 
 /*!
     \fn int operator<=( QChar c1, QChar c2 )
 
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of \a c1 is less than
     that of \a c2, or they are the same Unicode character; otherwise
     returns FALSE.
 */
 
 /*!
     \fn int operator<=( QChar c, char ch )
 
     \overload
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of \a c is less than or
     equal to that of the ASCII/Latin1 character \a ch; otherwise
     returns FALSE.
 */
 
 /*!
     \fn int operator<=( char ch, QChar c )
 
     \overload
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of the ASCII/Latin1
     character \a ch is less than or equal to that of \a c; otherwise
     returns FALSE.
 */
 
 /*!
     \fn int operator>=( QChar c1, QChar c2 )
 
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of \a c1 is greater than
     that of \a c2, or they are the same Unicode character; otherwise
     returns FALSE.
 */
 
 /*!
     \fn int operator>=( QChar c, char ch )
 
     \overload
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of \a c is greater than
     or equal to that of the ASCII/Latin1 character \a ch; otherwise
     returns FALSE.
 */
 
 /*!
     \fn int operator>=( char ch, QChar c )
 
     \overload
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of the ASCII/Latin1
     character \a ch is greater than or equal to that of \a c;
     otherwise returns FALSE.
 */
 
 /*!
     \fn int operator<( QChar c1, QChar c2 )
 
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of \a c1 is less than
     that of \a c2; otherwise returns FALSE.
 */
 
 /*!
     \fn int operator<( QChar c, char ch )
 
     \overload
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of \a c is less than that
     of the ASCII/Latin1 character \a ch; otherwise returns FALSE.
 */
 
 /*!
     \fn int operator<( char ch, QChar c )
 
     \overload
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of the ASCII/Latin1
     character \a ch is less than that of \a c; otherwise returns
     FALSE.
 */
 
 /*!
     \fn int operator>( QChar c1, QChar c2 )
 
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of \a c1 is greater than
     that of \a c2; otherwise returns FALSE.
 */
 
 /*!
     \fn int operator>( QChar c, char ch )
 
     \overload
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of \a c is greater than
     that of the ASCII/Latin1 character \a ch; otherwise returns FALSE.
 */
 
 /*!
     \fn int operator>( char ch, QChar c )
 
     \overload
     \relates QChar
 
     Returns TRUE if the numeric Unicode value of the ASCII/Latin1
     character \a ch is greater than that of \a c; otherwise returns
     FALSE.
 */
 
 #ifndef QT_NO_UNICODETABLES
 
 // small class used internally in QString::Compose()
 class QLigature
 {
 public:
     QLigature( QChar c );
 
     Q_UINT16 first() { cur = ligatures; return cur ? *cur : 0; }
     Q_UINT16 next() { return cur && *cur ? *(cur++) : 0; }
     Q_UINT16 current() { return cur ? *cur : 0; }
 
     int match(QString & str, unsigned int index);
     QChar head();
     QChar::Decomposition tag();
 
 private:
     Q_UINT16 *ligatures;
     Q_UINT16 *cur;
 };
 
 QLigature::QLigature( QChar c )
 {
     const Q_UINT16 *r = ligature_info[c.row()];
     if( !r )
 	ligatures = 0;
     else
     {
 	const Q_UINT16 pos = r[c.cell()];
 	ligatures = (Q_UINT16 *)&(ligature_map[pos]);
     }
     cur = ligatures;
 }
 
 QChar QLigature::head()
 {
     if(current())
 	return QChar(decomposition_map[current()+1]);
 
     return QChar::null;
 }
 
 QChar::Decomposition QLigature::tag()
 {
     if(current())
 	return (QChar::Decomposition) decomposition_map[current()];
 
     return QChar::Canonical;
 }
 
 int QLigature::match(QString & str, unsigned int index)
 {
     unsigned int i=index;
 
     if(!current()) return 0;
 
     Q_UINT16 lig = current() + 2;
     Q_UINT16 ch;
 
     while ((i < str.length()) && (ch = decomposition_map[lig])) {
 	if (str[(int)i] != QChar(ch))
 	    return 0;
 	i++;
 	lig++;
     }
 
     if (!decomposition_map[lig])
     {
 	return i-index;
     }
     return 0;
 }
 
 
 // this function is just used in QString::compose()
 static inline bool format(QChar::Decomposition tag, QString & str,
 			  int index, int len)
 {
     unsigned int l = index + len;
     unsigned int r = index;
 
     bool left = FALSE, right = FALSE;
 
     left = ((l < str.length()) &&
 	    ((str[(int)l].joining() == QChar::Dual) ||
 	     (str[(int)l].joining() == QChar::Right)));
     if (r > 0) {
 	r--;
 	//printf("joining(right) = %d\n", str[(int)r].joining());
 	right = (str[(int)r].joining() == QChar::Dual);
     }
 
 
     switch (tag) {
     case QChar::Medial:
 	return (left & right);
     case QChar::Initial:
 	return (left && !right);
     case QChar::Final:
 	return (right);// && !left);
     case QChar::Isolated:
     default:
 	return (!right && !left);
     }
 } // format()
 #endif
 
 /*
   QString::compose() and visual() were developed by Gordon Tisher
   <tisher@uniserve.ca>, with input from Lars Knoll <knoll@mpi-hd.mpg.de>,
   who developed the unicode data tables.
 */
 /*!
     \warning This function is not supported in Qt 3.x. It is provided
     for experimental and illustrative purposes only. It is mainly of
     interest to those experimenting with Arabic and other
     composition-rich texts.
 
     Applies possible ligatures to a QString. Useful when
     composition-rich text requires rendering with glyph-poor fonts,
     but it also makes compositions such as QChar(0x0041) ('A') and
     QChar(0x0308) (Unicode accent diaresis), giving QChar(0x00c4)
     (German A Umlaut).
 */
 void QString::compose()
 {
 #ifndef QT_NO_UNICODETABLES
     unsigned int index=0, len;
     unsigned int cindex = 0;
 
     QChar code, head;
 
     QMemArray<QChar> dia;
 
     QString composed = *this;
 
     while (index < length()) {
 	code = at(index);
 	//printf("\n\nligature for 0x%x:\n", code.unicode());
 	QLigature ligature(code);
 	ligature.first();
 	while(ligature.current()) {
 	    if ((len = ligature.match(*this, index)) != 0) {
 		head = ligature.head();
 		unsigned short code = head.unicode();
 		// we exclude Arabic presentation forms A and a few
 		// other ligatures, which are undefined in most fonts
 		if(!(code > 0xfb50 && code < 0xfe80) &&
 		   !(code > 0xfb00 && code < 0xfb2a)) {
 				// joining info is only needed for Arabic
 		    if (format(ligature.tag(), *this, index, len)) {
 			//printf("using ligature 0x%x, len=%d\n",code,len);
 			// replace letter
 			composed.replace(cindex, len, QChar(head));
 			index += len-1;
 			// we continue searching in case we have a final
 			// form because medial ones are preferred.
 			if ( len != 1 || ligature.tag() !=QChar::Final )
 			    break;
 		    }
 		}
 	    }
 	    ligature.next();
 	}
 	cindex++;
 	index++;
     }
     *this = composed;
 #endif
 }
 
 
 // These macros are used for efficient allocation of QChar strings.
 // IMPORTANT! If you change these, make sure you also change the
 // "delete unicode" statement in ~QStringData() in qstring.h correspondingly!
 
 #define QT_ALLOC_QCHAR_VEC( N ) (QChar*) new char[ sizeof(QChar)*( N ) ]
 #define QT_DELETE_QCHAR_VEC( P ) delete[] ((char*)( P ))
 
 
 /*!
     This utility function converts the 8-bit string \a ba to Unicode,
     returning the result.
 
     The caller is responsible for deleting the return value with
     delete[].
 */
 
-QChar* QString::asciiToUnicode( const QByteArray& ba, uint* len )
+QChar* QString::latin1ToUnicode( const QByteArray& ba, uint* len )
 {
     if ( ba.isNull() ) {
 	*len = 0;
 	return 0;
     }
     int l = 0;
     while ( l < (int)ba.size() && ba[l] )
 	l++;
     char* str = ba.data();
     QChar *uc = new QChar[ l ];   // Can't use macro, since function is public
     QChar *result = uc;
     if ( len )
 	*len = l;
     while (l--)
 	*uc++ = *str++;
     return result;
 }
 
-static QChar* internalAsciiToUnicode( const QByteArray& ba, uint* len )
+static QChar* internalLatin1ToUnicode( const QByteArray& ba, uint* len )
 {
     if ( ba.isNull() ) {
 	*len = 0;
 	return 0;
     }
     int l = 0;
     while ( l < (int)ba.size() && ba[l] )
 	l++;
     char* str = ba.data();
     QChar *uc = QT_ALLOC_QCHAR_VEC( l );
     QChar *result = uc;
     if ( len )
 	*len = l;
     while (l--)
 	*uc++ = *str++;
     return result;
 }
 
 /*!
     \overload
 
     This utility function converts the '\0'-terminated 8-bit string \a
     str to Unicode, returning the result and setting \a *len to the
     length of the Unicode string.
 
     The caller is responsible for deleting the return value with
     delete[].
 */
 
-QChar* QString::asciiToUnicode( const char *str, uint* len, uint maxlen )
+QChar* QString::latin1ToUnicode( const char *str, uint* len, uint maxlen )
 {
     QChar* result = 0;
     uint l = 0;
     if ( str ) {
 	if ( maxlen != (uint)-1 ) {
 	    while ( l < maxlen && str[l] )
 		l++;
 	} else {
 	    // Faster?
-	    l = qstrlen(str);
+	    l = strlen( str );
 	}
 	QChar *uc = new QChar[ l ]; // Can't use macro since function is public
 	result = uc;
 	uint i = l;
 	while ( i-- )
 	    *uc++ = *str++;
     }
     if ( len )
 	*len = l;
     return result;
 }
 
-static QChar* internalAsciiToUnicode( const char *str, uint* len,
+static QChar* internalLatin1ToUnicode( const char *str, uint* len,
 				      uint maxlen = (uint)-1 )
 {
     QChar* result = 0;
     uint l = 0;
     if ( str ) {
 	if ( maxlen != (uint)-1 ) {
 	    while ( l < maxlen && str[l] )
 		l++;
 	} else {
 	    // Faster?
-	    l = qstrlen(str);
+	    l = strlen( str );
 	}
 	QChar *uc = QT_ALLOC_QCHAR_VEC( l );
 	result = uc;
 	uint i = l;
 	while ( i-- )
 	    *uc++ = *str++;
     }
     if ( len )
 	*len = l;
     return result;
 }
 
 /*!
     This utility function converts \a l 16-bit characters from \a uc
     to ASCII, returning a '\0'-terminated string.
 
     The caller is responsible for deleting the resultant string with
     delete[].
 */
-char* QString::unicodeToAscii(const QChar *uc, uint l)
+char* QString::unicodeToLatin1(const QChar *uc, uint l)
 {
     if (!uc) {
 	return 0;
     }
     char *a = new char[l+1];
     char *result = a;
     while (l--) {
 	*a++ = (uc->unicode() > 0xff) ? '?' : (char)uc->unicode();
 	uc++;
     }
     *a = '\0';
     return result;
 }
 
 /*****************************************************************************
   QString member functions
  *****************************************************************************/
 
 /*!
     \class QString qstring.h
     \reentrant
 
     \brief The QString class provides an abstraction of Unicode text
     and the classic C '\0'-terminated char array.
 
     \ingroup tools
     \ingroup shared
     \ingroup text
     \mainclass
 
     QString uses \link shclass.html implicit sharing\endlink, which
     makes it very efficient and easy to use.
 
     In all of the QString methods that take \c {const char *}
     parameters, the \c {const char *} is interpreted as a classic
     C-style '\0'-terminated ASCII string. It is legal for the \c
     {const char *} parameter to be 0. If the \c {const char *} is not
     '\0'-terminated, the results are undefined. Functions that copy
     classic C strings into a QString will not copy the terminating
     '\0' character. The QChar array of the QString (as returned by
     unicode()) is generally not terminated by a '\0'. If you need to
     pass a QString to a function that requires a C '\0'-terminated
     string use latin1().
 
     \keyword QString::null
     A QString that has not been assigned to anything is \e null, i.e.
     both the length and data pointer is 0. A QString that references
     the empty string ("", a single '\0' char) is \e empty. Both null
     and empty QStrings are legal parameters to the methods. Assigning
     \c{(const char *) 0} to QString gives a null QString. For
     convenience, \c QString::null is a null QString. When sorting,
     empty strings come first, followed by non-empty strings, followed
     by null strings. We recommend using \c{if ( !str.isNull() )} to
     check for a non-null string rather than \c{if ( !str )}; see \l
     operator!() for an explanation.
 
     Note that if you find that you are mixing usage of \l QCString,
     QString, and \l QByteArray, this causes lots of unnecessary
     copying and might indicate that the true nature of the data you
     are dealing with is uncertain. If the data is '\0'-terminated 8-bit
     data, use \l QCString; if it is unterminated (i.e. contains '\0's)
     8-bit data, use \l QByteArray; if it is text, use QString.
 
     Lists of strings are handled by the QStringList class. You can
     split a string into a list of strings using QStringList::split(),
     and join a list of strings into a single string with an optional
     separator using QStringList::join(). You can obtain a list of
     strings from a string list that contain a particular substring or
     that match a particular \link qregexp.html regex\endlink using
     QStringList::grep().
 
     <b>Note for C programmers</b>
 
     Due to C++'s type system and the fact that QString is implicitly
     shared, QStrings may be treated like ints or other simple base
     types. For example:
 
     \code
     QString boolToString( bool b )
     {
 	QString result;
 	if ( b )
 	    result = "True";
 	else
 	    result = "False";
 	return result;
     }
     \endcode
 
     The variable, result, is an auto variable allocated on the stack.
     When return is called, because we're returning by value, The copy
     constructor is called and a copy of the string is returned. (No
     actual copying takes place thanks to the implicit sharing, see
     below.)
 
     Throughout Qt's source code you will encounter QString usages like
     this:
     \code
     QString func( const QString& input )
     {
 	QString output = input;
 	// process output
 	return output;
     }
     \endcode
 
     The 'copying' of input to output is almost as fast as copying a
     pointer because behind the scenes copying is achieved by
     incrementing a reference count. QString (like all Qt's implicitly
     shared classes) operates on a copy-on-write basis, only copying if
     an instance is actually changed.
 
     If you wish to create a deep copy of a QString without losing any
     Unicode information then you should use QDeepCopy.
 
     \sa QChar QCString QByteArray QConstString
 */
 
 /*! \enum Qt::ComparisonFlags
 \internal
 */
 /*!
     \enum Qt::StringComparisonMode
 
     This enum type is used to set the string comparison mode when
     searching for an item. It is used by QListBox, QListView and
     QIconView, for example. We'll refer to the string being searched
     as the 'target' string.
 
     \value CaseSensitive The strings must match case sensitively.
     \value ExactMatch The target and search strings must match exactly.
     \value BeginsWith The target string begins with the search string.
     \value EndsWith The target string ends with the search string.
     \value Contains The target string contains the search string.
 
     If you OR these flags together (excluding \c CaseSensitive), the
     search criteria be applied in the following order: \c ExactMatch,
     \c BeginsWith, \c EndsWith, \c Contains.
 
     Matching is case-insensitive unless \c CaseSensitive is set. \c
     CaseSensitive may be OR-ed with any combination of the other
     flags.
 
 */
 Q_EXPORT QStringData *QString::shared_null = 0;
 QT_STATIC_CONST_IMPL QString QString::null;
 QT_STATIC_CONST_IMPL QChar QChar::null;
 QT_STATIC_CONST_IMPL QChar QChar::replacement((ushort)0xfffd);
 QT_STATIC_CONST_IMPL QChar QChar::byteOrderMark((ushort)0xfeff);
 QT_STATIC_CONST_IMPL QChar QChar::byteOrderSwapped((ushort)0xfffe);
 QT_STATIC_CONST_IMPL QChar QChar::nbsp((ushort)0x00a0);
 
 QStringData* QString::makeSharedNull()
 {
     QString::shared_null = new QStringData;
 #if defined( Q_OS_MAC )
     QString *that = const_cast<QString *>(&QString::null);
     that->d = QString::shared_null;
 #endif
     return QString::shared_null;
 }
 
-// Uncomment this to get some useful statistics.
-// #define Q2HELPER(x) x
-
-#ifdef Q2HELPER
-static int stat_construct_charstar=0;
-static int stat_construct_charstar_size=0;
-static int stat_construct_null=0;
-static int stat_construct_int=0;
-static int stat_construct_int_size=0;
-static int stat_construct_ba=0;
-static int stat_get_ascii=0;
-static int stat_get_ascii_size=0;
-static int stat_copy_on_write=0;
-static int stat_copy_on_write_size=0;
-static int stat_fast_copy=0;
-Q_EXPORT void qt_qstring_stats()
-{
-	qDebug("construct_charstar = %d (%d chars)", stat_construct_charstar, stat_construct_charstar_size);
-	qDebug("construct_null = %d", stat_construct_null);
-	qDebug("construct_int = %d (%d chars)", stat_construct_int, stat_construct_int_size);
-	qDebug("construct_ba = %d", stat_construct_ba);
-	qDebug("get_ascii = %d (%d chars)", stat_get_ascii, stat_get_ascii_size);
-	qDebug("copy_on_write = %d (%d chars)", stat_copy_on_write, stat_copy_on_write_size);
-	qDebug("fast_copy = %d", stat_fast_copy);
-}
-#else
-#define Q2HELPER(x)
-#endif
-
 /*!
     \fn QString::QString()
 
     Constructs a null string, i.e. both the length and data pointer
     are 0.
 
     \sa isNull()
 */
 
 /*!
     Constructs a string of length one, containing the character \a ch.
 */
 QString::QString( QChar ch )
 {
     d = new QStringData( QT_ALLOC_QCHAR_VEC( 1 ), 1, 1 );
     d->unicode[0] = ch;
 }
 
 /*!
     Constructs an implicitly shared copy of \a s. This is very fast
     since it only involves incrementing a reference count.
 */
 QString::QString( const QString &s ) :
     d(s.d)
 {
-    Q2HELPER(stat_fast_copy++)
     d->ref();
 }
 
 /*!
   \internal
 
   Private function.
 
   Constructs a string with preallocated space for \a size characters.
 
   The string is empty.
 
   \sa isNull()
 */
 
 QString::QString( int size, bool /*dummy*/ )
 {
     if ( size ) {
-	Q2HELPER(stat_construct_int++)
 	int l = size;
-	Q2HELPER(stat_construct_int_size+=l)
 	QChar* uc = QT_ALLOC_QCHAR_VEC( l );
 	d = new QStringData( uc, 0, l );
     } else {
-	Q2HELPER(stat_construct_null++)
 	d = shared_null ? shared_null : (shared_null=new QStringData);
 	d->ref();
     }
 }
 
 /*!
     Constructs a string that is a deep copy of \a ba interpreted as a
     classic C string.
 */
 
 QString::QString( const QByteArray& ba )
 {
-    Q2HELPER(stat_construct_ba++)
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+	d = 0;
+	*this = fromAscii( ba.data(), ba.size() );
+	return;
+    }
+#endif
     uint l;
-    QChar *uc = internalAsciiToUnicode(ba,&l);
+    QChar *uc = internalLatin1ToUnicode(ba,&l);
     d = new QStringData(uc,l,l);
 }
 
 /*!
     Constructs a string that is a deep copy of the first \a length
     characters in the QChar array.
 
     If \a unicode and \a length are 0, then a null string is created.
 
     If only \a unicode is 0, the string is empty but has \a length
     characters of space preallocated: QString expands automatically
     anyway, but this may speed up some cases a little. We recommend
     using the plain constructor and setLength() for this purpose since
     it will result in more readable code.
 
     \sa isNull() setLength()
 */
 
 QString::QString( const QChar* unicode, uint length )
 {
     if ( !unicode && !length ) {
 	d = shared_null ? shared_null : makeSharedNull();
 	d->ref();
     } else {
 	QChar* uc = QT_ALLOC_QCHAR_VEC( length );
 	if ( unicode )
 	    memcpy(uc, unicode, length*sizeof(QChar));
 	d = new QStringData(uc,unicode ? length : 0,length);
     }
 }
 
 /*!
     Constructs a string that is a deep copy of \a str, interpreted as
     a classic C string.
 
     If \a str is 0, then a null string is created.
 
     This is a cast constructor, but it is perfectly safe: converting a
     Latin1 const char* to QString preserves all the information. You
     can disable this constructor by defining \c QT_NO_CAST_ASCII when
     you compile your applications. You can also make QString objects
     by using setLatin1(), fromLatin1(), fromLocal8Bit(), and
     fromUtf8(). Or whatever encoding is appropriate for the 8-bit data
     you have.
 
     \sa isNull()
 */
 
 QString::QString( const char *str )
 {
-    Q2HELPER(stat_construct_charstar++)
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+	d = 0;
+	*this = fromAscii( str );
+	return;
+    }
+#endif
+    uint l;
+    QChar *uc = internalLatin1ToUnicode(str,&l);
+    d = new QStringData(uc,l,l);
+}
+
+#ifndef QT_NO_STL
+/*!
+    Constructs a string that is a deep copy of \a str.
+
+    This is the same as fromAscii(\a str).
+*/
+
+QString::QString( const std::string &str )
+{
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+	d = 0;
+	*this = fromAscii( str.c_str() );
+	return;
+    }
+#endif
     uint l;
-    QChar *uc = internalAsciiToUnicode(str,&l);
-    Q2HELPER(stat_construct_charstar_size+=l)
+    QChar *uc = internalLatin1ToUnicode(str.c_str(),&l);
     d = new QStringData(uc,l,l);
 }
+#endif
 
 /*!
     \fn QString::~QString()
 
     Destroys the string and frees the string's data if this is the
     last reference to the string.
 */
 
 
 /*!
     Deallocates any space reserved solely by this QString.
 
     If the string does not share its data with another QString
     instance, nothing happens; otherwise the function creates a new,
     unique copy of this string. This function is called whenever the
     string is modified.
 */
 
 void QString::real_detach()
 {
     setLength( length() );
 }
 
 void QString::deref()
 {
-    if ( d->deref() ) {
+    if ( d && d->deref() ) {
 	if ( d != shared_null )
 	    delete d;
-	d = 0; // helps debugging
+	d = 0;
     }
 }
 
 void QStringData::deleteSelf()
 {
     delete this;
 }
 
 /*!
     \fn QString& QString::operator=( QChar c )
 
     Sets the string to contain just the single character \a c.
 */
 
 /*!
+    \fn QString& QString::operator=( const std::string& s )
+
+    \overload
+
+    Makes a deep copy of \a s and returns a reference to the deep
+    copy.
+*/
+
+/*!
     \fn QString& QString::operator=( char c )
 
     \overload
 
     Sets the string to contain just the single character \a c.
 */
 
 /*!
     \overload
 
     Assigns a shallow copy of \a s to this string and returns a
     reference to this string. This is very fast because the string
     isn't actually copied.
 */
 QString &QString::operator=( const QString &s )
 {
-    Q2HELPER(stat_fast_copy++)
     s.d->ref();
     deref();
     d = s.d;
     return *this;
 }
 
 /*!
     \overload
 
     Assigns a deep copy of \a cs, interpreted as a classic C string,
     to this string and returns a reference to this string.
 */
 QString &QString::operator=( const QCString& cs )
 {
-    return setLatin1(cs);
+    return setAscii(cs);
 }
 
 
 /*!
     \overload
 
     Assigns a deep copy of \a str, interpreted as a classic C string
     to this string and returns a reference to this string.
 
     If \a str is 0, then a null string is created.
 
     \sa isNull()
 */
 QString &QString::operator=( const char *str )
 {
-    return setLatin1(str);
+    return setAscii(str);
 }
 
 
 /*!
     \fn bool QString::isNull() const
 
     Returns TRUE if the string is null; otherwise returns FALSE. A
     null string is always empty.
 
     \code
 	QString a;          // a.unicode() == 0, a.length() == 0
 	a.isNull();         // TRUE, because a.unicode() == 0
 	a.isEmpty();        // TRUE
     \endcode
 
     \sa isEmpty(), length()
 */
 
 /*!
     \fn bool QString::isEmpty() const
 
     Returns TRUE if the string is empty, i.e. if length() == 0;
     otherwise returns FALSE. Null strings are also empty.
 
     \code
 	QString a( "" );
 	a.isEmpty();        // TRUE
 	a.isNull();         // FALSE
 
 	QString b;
 	b.isEmpty();        // TRUE
 	b.isNull();         // TRUE
     \endcode
 
     \sa isNull(), length()
 */
 
 /*!
     \fn uint QString::length() const
 
     Returns the length of the string.
 
     Null strings and empty strings have zero length.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     If \a newLen is less than the length of the string, then the
     string is truncated at position \a newLen. Otherwise nothing
     happens.
 
     \code
 	QString s = "truncate me";
 	s.truncate( 5 );            // s == "trunc"
     \endcode
 
     \sa setLength()
 */
 
 void QString::truncate( uint newLen )
 {
     if ( newLen < d->len )
 	setLength( newLen );
 }
 
 /*!
     Ensures that at least \a newLen characters are allocated to the
     string, and sets the length of the string to \a newLen. Any new
     space allocated contains arbitrary data.
 
-    If \a newLen is 0, then the string becomes empty, unless the
-    string is null, in which case it remains null.
+    If \a newLen is 0, then the string becomes empty (non-null).
 
     If it is not possible to allocate enough memory, the string
     remains unchanged.
 
     This function always detaches the string from other references to
     the same data.
 
     This function is useful for code that needs to build up a long
     string and wants to avoid repeated reallocation. In this example,
     we want to add to the string until some condition is true, and
     we're fairly sure that size is big enough:
     \code
 	QString result;
-	int resultLength = 0;
-	result.setLength( newLen ) // allocate some space
+	int len = 0;
+	result.setLength( maxLen );     // allocate some space
 	while ( ... ) {
-	    result[resultLength++] = ... // fill (part of) the space with data
+	    result[len++] = ...         // fill part of the space
 	}
-	result.truncate[resultLength]; // and get rid of the undefined junk
+	result.truncate( len );         // and get rid of the rest
     \endcode
 
     If \a newLen is an underestimate, the worst that will happen is
     that the loop will slow down.
 
     \sa truncate(), isNull(), isEmpty(), length()
 */
 
 void QString::setLength( uint newLen )
 {
     if ( d->count != 1 || newLen > d->maxl ||
 	 ( newLen * 4 < d->maxl && d->maxl > 4 ) ) {
 	// detach, grow or shrink
-	Q2HELPER(stat_copy_on_write++)
-	Q2HELPER(stat_copy_on_write_size+=d->len)
 	uint newMax = computeNewMax( newLen );
 	QChar* nd = QT_ALLOC_QCHAR_VEC( newMax );
 	if ( nd ) {
 	    uint len = QMIN( d->len, newLen );
 	    if ( d->unicode )
 		memcpy( nd, d->unicode, sizeof(QChar)*len );
 	    deref();
 	    d = new QStringData( nd, newLen, newMax );
 	}
     } else {
 	d->len = newLen;
 	d->setDirty();
     }
 }
 
 /*!
     This function will return a string that replaces the lowest
     numbered occurrence of \c %1, \c %2, ..., \c %9 with \a a.
 
     The \a fieldwidth value specifies the minimum amount of space that
     \a a is padded to. A positive value will produce right-aligned
     text, whereas a negative value will produce left-aligned text.
 
+    The following example shows how we could create a 'status' string
+    when processing a list of files:
     \code
-	QString firstName( "Joe" );
-	QString lastName( "Bloggs" );
-	QString fullName;
-	fullName = QString( "First name is '%1', last name is '%2'" )
-		    .arg( firstName )
-		    .arg( lastName );
-
-	// fullName == First name is 'Joe', last name is 'Bloggs'
+    QString status = QString( "Processing file %1 of %2: %3" )
+			.arg( i )         // current file's number
+			.arg( total )     // number of files to process
+			.arg( fileName ); // current file's name
     \endcode
 
-    Note that using arg() to construct sentences as we've done in the
-    example above does not usually translate well into other languages
-    because sentence structure and word order often differ between
-    languages.
+    It is generally fine to use filenames and numbers as we have done
+    in the example above. But note that using arg() to construct
+    natural language sentences does not usually translate well into
+    other languages because sentence structure and word order often
+    differ between languages.
 
     If there is no place marker (\c %1 or \c %2, etc.), a warning
     message (qWarning()) is output and the text is appended at the
     end of the string. We recommend that the correct number of place
     markers is always used in production code.
 */
 QString QString::arg( const QString& a, int fieldwidth ) const
 {
     int pos, len;
     QString r = *this;
 
     if ( !findArg( pos, len ) ) {
 	qWarning( "QString::arg(): Argument missing: %s, %s",
 		  latin1(), a.latin1() );
 	// Make sure the text at least appears SOMEWHERE
 	r += ' ';
 	pos = r.length();
 	len = 0;
     }
 
     r.replace( pos, len, a );
     if ( fieldwidth < 0 ) {
 	QString s;
 	while ( (uint)-fieldwidth > a.length() ) {
 	    s += ' ';
 	    fieldwidth++;
 	}
 	r.insert( pos + a.length(), s );
     } else if ( fieldwidth ) {
 	QString s;
 	while ( (uint)fieldwidth > a.length() ) {
 	    s += ' ';
 	    fieldwidth--;
 	}
 	r.insert( pos, s );
     }
 
     return r;
 }
 
 
 /*!
     \overload
 
     The \a fieldwidth value specifies the minimum amount of space that
     \a a is padded to. A positive value will produce a right-aligned
     number, whereas a negative value will produce a left-aligned
     number.
 
     \a a is expressed in base \a base, which is 10 by default and must
     be between 2 and 36.
 
     \code
 	QString str;
 	str = QString( "Decimal 63 is %1 in hexadecimal" )
 		.arg( 63, 0, 16 );
 	// str == "Decimal 63 is 3f in hexadecimal"
     \endcode
 */
 QString QString::arg( long a, int fieldwidth, int base ) const
 {
     return arg( QString::number(a, base), fieldwidth );
 }
 
 /*!
     \overload
 
     \a a is expressed in base \a base, which is 10 by default and must
     be between 2 and 36.
 */
 QString QString::arg( ulong a, int fieldwidth, int base ) const
 {
     return arg( QString::number(a, base), fieldwidth );
 }
 
 /*!
     \fn QString QString::arg( int a, int fieldwidth, int base ) const
 
     \overload
 
     \a a is expressed in base \a base, which is 10 by default and must
     be between 2 and 36.
 */
 
 /*!
     \fn QString QString::arg( uint a, int fieldwidth, int base ) const
 
     \overload
 
     \a a is expressed in base \a base, which is 10 by default and must
     be between 2 and 36.
 */
 
 /*!
     \fn QString QString::arg( short a, int fieldwidth, int base ) const
 
     \overload
 
     \a a is expressed in base \a base, which is 10 by default and must
     be between 2 and 36.
 */
 
 /*!
     \fn QString QString::arg( ushort a, int fieldwidth, int base ) const
 
     \overload
 
     \a a is expressed in base \a base, which is 10 by default and must
     be between 2 and 36.
 */
 
 
 /*!
     \overload
 
     \a a is assumed to be in the Latin1 character set.
 */
 QString QString::arg( char a, int fieldwidth ) const
 {
     QString c;
     c += a;
     return arg( c, fieldwidth );
 }
 
 /*!
     \overload
 */
 QString QString::arg( QChar a, int fieldwidth ) const
 {
     QString c;
     c += a;
     return arg( c, fieldwidth );
 }
 
 /*!
     \overload
 
     \target arg-formats
 
     Argument \a a is formatted according to the \a fmt format specified,
     which is 'g' by default and can be any of the following:
 
     \table
     \header \i Format \i Meaning
     \row \i \c e \i format as [-]9.9e[+|-]999
     \row \i \c E \i format as [-]9.9E[+|-]999
     \row \i \c f \i format as [-]9.9
     \row \i \c g \i use \c e or \c f format, whichever is the most concise
     \row \i \c G \i use \c E or \c f format, whichever is the most concise
     \endtable
 
     With 'e', 'E', and 'f', \a prec is the number of digits after the
     decimal point. With 'g' and 'G', \a prec is the maximum number of
     significant digits (trailing zeroes are omitted).
 
     \code
 	double d = 12.34;
 	QString ds = QString( "'E' format, precision 3, gives %1" )
 			.arg( d, 0, 'E', 3 );
 	// ds == "1.234E+001"
     \endcode
 */
 QString QString::arg( double a, int fieldwidth, char fmt, int prec ) const
 {
     return arg( QString::number( a, fmt, prec ), fieldwidth );
 }
 
 
 /*
     Just 1-digit arguments.
 */
 bool QString::findArg( int& pos, int& len ) const
 {
     char lowest=0;
     register const QChar *uc = d->unicode;
     const uint l = length();
     for (uint i = 0; i < l; i++) {
 	if ( uc[i] == '%' && i+1<l ) {
 	    QChar dig = uc[i+1];
 	    if ( dig >= '0' && dig <= '9' ) {
 		if ( !lowest || dig < lowest ) {
 		    lowest = dig;
 		    pos = i;
 		    len = 2;
 		}
 	    }
 	}
     }
     return lowest != 0;
 }
 
 /*!
     Safely builds a formatted string from the format string \a cformat
     and an arbitrary list of arguments. The format string supports all
     the escape sequences of printf() in the standard C library.
 
     The %s escape sequence expects a utf8() encoded string. The format
     string \e cformat is expected to be in latin1. If you need a
     Unicode format string, use arg() instead. For typesafe string
     building, with full Unicode support, you can use QTextOStream like
     this:
 
     \code
 	QString str;
 	QString s = ...;
 	int x = ...;
 	QTextOStream( &str ) << s << " : " << x;
     \endcode
 
     For \link QObject::tr() translations,\endlink especially if the
     strings contains more than one escape sequence, you should
     consider using the arg() function instead. This allows the order
     of the replacements to be controlled by the translator, and has
     Unicode support.
 
     \sa arg()
 */
 
 #ifndef QT_NO_SPRINTF
 QString &QString::sprintf( const char* cformat, ... )
 {
     va_list ap;
     va_start( ap, cformat );
 
     if ( !cformat || !*cformat ) {
 	// Qt 1.x compat
 	*this = fromLatin1( "" );
 	return *this;
     }
-    QString format = fromLatin1( cformat );
+    QString format = fromAscii( cformat );
 
     QRegExp escape( "%#?0?-? ?\\+?'?[0-9*]*\\.?[0-9*]*h?l?L?q?Z?" );
     QString result;
     uint last = 0;
     int pos;
     int len = 0;
 
     for (;;) {
 	pos = escape.search( format, last );
 	len = escape.matchedLength();
 	// Non-escaped text
 	if ( pos > (int)last )
 	    result += format.mid( last, pos - last );
 	if ( pos < 0 ) {
 	    // The rest
 	    if ( last < format.length() )
 		result += format.mid( last );
 	    break;
 	}
 	last = pos + len + 1;
 
 	// Escape
 	QString f = format.mid( pos, len );
 	uint width, decimals;
 	int params = 0;
 	int wpos = f.find('*');
 	if ( wpos >= 0 ) {
 	    params++;
 	    width = va_arg( ap, int );
 	    if ( f.find('*', wpos + 1) >= 0 ) {
 		decimals = va_arg( ap, int );
 		params++;
 	    } else {
 		decimals = 0;
 	    }
 	} else {
 	    decimals = width = 0;
 	}
 	QString replacement;
 	if ( format[pos + len] == 's' || format[pos + len] == 'S' ||
 	     format[pos + len] == 'c' )
 	{
 	    bool rightjust = ( f.find('-') < 0 );
 	    // %-5s really means left adjust in sprintf
 
 	    if ( wpos < 0 ) {
 		QRegExp num( fromLatin1("[0-9]+") );
 		int p = num.search( f );
 		int nlen = num.matchedLength();
 		int q = f.find( '.' );
 		if ( q < 0 || (p < q && p >= 0) )
 		    width = f.mid( p, nlen ).toInt();
 		if ( q >= 0 ) {
 		    p = num.search( f, q );
 		    // "decimals" is used to specify string truncation
 		    if ( p >= 0 )
 			decimals = f.mid( p, nlen ).toInt();
 		}
 	    }
 
 	    if ( format[pos + len] == 's' ) {
 		QString s = QString::fromUtf8( va_arg(ap, char*) );
 		replacement = ( decimals <= 0 ) ? s : s.left( decimals );
 	    } else {
 		int ch = va_arg(ap, int);
 		replacement = QChar((ushort)ch);
 	    }
 	    if ( replacement.length() < width ) {
 		replacement = rightjust
 		    ? replacement.rightJustify(width)
 		    : replacement.leftJustify(width);
 	    }
 	} else if ( format[pos+len] == '%' ) {
 	    replacement = '%';
 	} else if ( format[pos+len] == 'n' ) {
 	    int* n = va_arg(ap, int*);
 	    *n = result.length();
 	} else {
 	    char in[64], out[330];
 	    strncpy(in,f.latin1(),63);
 	    out[0] = '\0';
 	    char fch = format[pos+len].latin1();
 	    in[f.length()] = fch;
 	    switch ( fch ) {
 	    case 'd':
 	    case 'i':
 	    case 'o':
 	    case 'u':
 	    case 'x':
 	    case 'X':
 		{
 		    int value = va_arg( ap, int );
 		    switch ( params ) {
 		    case 0:
 			::sprintf( out, in, value );
 			break;
 		    case 1:
 			::sprintf( out, in, width, value );
 			break;
 		    case 2:
 			::sprintf( out, in, width, decimals, value );
 		    }
 		}
 		break;
 	    case 'e':
 	    case 'E':
 	    case 'f':
 	    case 'g':
 	    case 'G':
 		{
 		    double value = va_arg( ap, double );
 		    switch ( params ) {
 		    case 0:
 			::sprintf( out, in, value );
 			break;
 		    case 1:
 			::sprintf( out, in, width, value );
 			break;
 		    case 2:
 			::sprintf( out, in, width, decimals, value );
 		    }
 		}
 		break;
 	    case 'p':
 		{
 		    void* value = va_arg( ap, void * );
 		    switch ( params ) {
 		    case 0:
 			::sprintf( out, in, value );
 			break;
 		    case 1:
 			::sprintf( out, in, width, value );
 			break;
 		    case 2:
 			::sprintf( out, in, width, decimals, value );
 		    }
 		}
 	    }
-	    replacement = fromLatin1( out );
+	    replacement = fromAscii( out );
 	}
 	result += replacement;
     }
     *this = result;
 
     va_end( ap );
     return *this;
 }
 #endif
 
 /*!
     Fills the string with \a len characters of value \a c, and returns
     a reference to the string.
 
     If \a len is negative (the default), the current string length is
     used.
 
     \code
 	QString str;
 	str.fill( 'g', 5 );      // string == "ggggg"
     \endcode
 */
 
 QString& QString::fill( QChar c, int len )
 {
     if ( len < 0 )
 	len = length();
     if ( len == 0 ) {
 	*this = "";
     } else {
 	deref();
 	QChar * nd = QT_ALLOC_QCHAR_VEC( len );
 	d = new QStringData(nd,len,len);
 	while (len--) *nd++ = c;
     }
     return *this;
 }
 
 
 /*!
   \fn QString QString::copy() const
 
   \obsolete
 
   In Qt 2.0 and later, all calls to this function are needless. Just
   remove them.
 */
 
 /*!
     \overload
 
     Finds the first occurrence of the character \a c, starting at
     position \a index. If \a index is -1, the search starts at the
     last character; if -2, at the next to last character and so on.
     (See findRev() for searching backwards.)
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 
     Returns the position of \a c or -1 if \a c could not be found.
 */
 
 int QString::find( QChar c, int index, bool cs ) const
 {
     const uint l = length();
     if ( index < 0 )
 	index += l;
     if ( (uint)index >= l )
 	return -1;
     register const QChar *uc = unicode()+index;
     const QChar *end = unicode() + l;
     if ( cs ) {
 	while ( uc < end && *uc != c )
 	    uc++;
     } else {
 	c = ::lower( c );
 	while ( uc < end && ::lower( *uc ) != c )
 	    uc++;
     }
     if ( uint(uc - unicode()) >= l )
 	return -1;
     return (int)(uc - unicode());
 }
 
 /* an implementation of the Boyer-Moore search algorithm
 */
 
 /* initializes the skiptable to know haw far ahead we can skip on a wrong match
 */
 static void bm_init_skiptable( const QString &pattern, uint *skiptable, bool cs )
 {
     int i = 0;
     register uint *st = skiptable;
     int l = pattern.length();
     while ( i++ < 0x100/8 ) {
 	*(st++) = l;
 	*(st++) = l;
 	*(st++) = l;
 	*(st++) = l;
 	*(st++) = l;
 	*(st++) = l;
 	*(st++) = l;
 	*(st++) = l;
     }
     const QChar *uc = pattern.unicode();
     if ( cs ) {
 	while( l-- ) {
 	    skiptable[ uc->cell() ] = l;
 	    uc++;
 	}
     } else {
 	while( l-- ) {
 	    skiptable[ ::lower( *uc ).cell() ] = l;
 	    uc++;
 	}
     }
 }
 
 static int bm_find( const QString &str, int index, const QString &pattern, uint *skiptable, bool cs )
 {
     const uint l = str.length();
     if ( pattern.isEmpty() )
 	return index > (int)l ? -1 : index;
 
     const QChar *uc = str.unicode();
     const QChar *puc = pattern.unicode();
     const uint pl = pattern.length();
     const uint pl_minus_one = pl - 1;
 
     register const QChar *current = uc + index + pl_minus_one;
     const QChar *end = uc + l;
     if ( cs ) {
 	while( current < end ) {
 	    uint skip = skiptable[ current->cell() ];
 	    if ( !skip ) {
 		// possible match
 		while( skip < pl ) {
 		    if ( *(current - skip ) != puc[pl_minus_one-skip] )
 			break;
 		    skip++;
 		}
 		if ( skip > pl_minus_one ) { // we have a match
 		    return (current - uc) - skip + 1;
 		}
 		// in case we don't have a match we are a bit inefficient as we only skip by one
 		// when we have the non matching char in the string.
 		if ( skiptable[ (current-skip)->cell() ] == pl )
 		    skip = pl - skip;
 		else
 		    skip = 1;
 	    }
 	    current += skip;
 	}
     } else {
 	while( current < end ) {
 	    uint skip = skiptable[ ::lower( *current ).cell() ];
 	    if ( !skip ) {
 		// possible match
 		while( skip < pl ) {
 		    if ( ::lower( *(current - skip) ) != ::lower( puc[pl_minus_one-skip] ) )
 			break;
 		    skip++;
 		}
 		if ( skip > pl_minus_one ) // we have a match
 		    return (current - uc) - skip + 1;
 		// in case we don't have a match we are a bit inefficient as we only skip by one
 		// when we have the non matching char in the string.
 		if ( skiptable[ ::lower( (current - skip)->cell() ) ] == pl )
 		    skip = pl - skip;
 		else
 		    skip = 1;
 	    }
 	    current += skip;
 	}
     }
     // not found
     return -1;
 }
 
 
 #define REHASH( a ) \
     if ( sl_minus_1 < sizeof(uint) * CHAR_BIT ) \
 	hashHaystack -= (a) << sl_minus_1; \
     hashHaystack <<= 1
 
 /*!
     \overload
 
     Finds the first occurrence of the string \a str, starting at
     position \a index. If \a index is -1, the search starts at the
     last character, if it is -2, at the next to last character and so
     on. (See findRev() for searching backwards.)
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 
     Returns the position of \a str or -1 if \a str could not be found.
 */
 
 int QString::find( const QString& str, int index, bool cs ) const
 {
     const uint l = length();
     const uint sl = str.length();
     if ( index < 0 )
 	index += l;
     if ( sl + index > l )
 	return -1;
     if ( !sl )
 	return index;
 
+#ifndef MACOSX_101
     if ( sl == 1 )
 	return find( *str.unicode(), index, cs );
+#endif
 
     // we use the Boyer-Moore algorithm in cases where the overhead
     // for the hash table should pay off, otherwise we use a simple
     // hash function
     if ( l > 500 && sl > 5 ) {
 	uint skiptable[0x100];
 	bm_init_skiptable( str, skiptable, cs );
 	return bm_find( *this, index, str, skiptable, cs );
     }
 
     /*
       We use some hashing for efficiency's sake. Instead of
       comparing strings, we compare the hash value of str with that of
       a part of this QString. Only if that matches, we call ucstrncmp
       or ucstrnicmp.
     */
     const QChar* needle = str.unicode();
     const QChar* haystack = unicode() + index;
     const QChar* end = unicode() + (l-sl);
     const uint sl_minus_1 = sl-1;
     uint hashNeedle = 0, hashHaystack = 0, i;
 
     if ( cs ) {
 	for ( i = 0; i < sl; ++i ) {
 	    hashNeedle = ((hashNeedle<<1) + needle[i].unicode() );
 	    hashHaystack = ((hashHaystack<<1) + haystack[i].unicode() );
 	}
 	hashHaystack -= (haystack+sl_minus_1)->unicode();
 
 	while ( haystack <= end ) {
 	    hashHaystack += (haystack+sl_minus_1)->unicode();
  	    if ( hashHaystack == hashNeedle
 		 && ucstrncmp( needle, haystack, sl ) == 0 )
 		return haystack-unicode();
 
 	    REHASH( haystack->unicode() );
 	    ++haystack;
 	}
     } else {
 	for ( i = 0; i < sl; ++i ) {
 	    hashNeedle = ((hashNeedle<<1) +
 			  ::lower( needle[i].unicode() ).unicode() );
 	    hashHaystack = ((hashHaystack<<1) +
 			    ::lower( haystack[i].unicode() ).unicode() );
 	}
 
 	hashHaystack -= ::lower(*(haystack+sl_minus_1)).unicode();
 	while ( haystack <= end ) {
 	    hashHaystack += ::lower(*(haystack+sl_minus_1)).unicode();
 	    if ( hashHaystack == hashNeedle
 		 && ucstrnicmp( needle, haystack, sl ) == 0 )
 		return haystack-unicode();
 
 	    REHASH( ::lower(*haystack).unicode() );
 	    ++haystack;
 	}
     }
     return -1;
 }
 
 /*!
     \fn int QString::findRev( const char* str, int index ) const
 
     Equivalent to findRev(QString(\a str), \a index).
 */
 
 /*!
     \fn int QString::find( const char* str, int index ) const
 
     \overload
 
     Equivalent to find(QString(\a str), \a index).
 */
 
 /*!
     \overload
 
     Finds the first occurrence of the character \a c, starting at
     position \a index and searching backwards. If the index is -1, the
     search starts at the last character, if it is -2, at the next to
     last character and so on.
 
     Returns the position of \a c or -1 if \a c could not be found.
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 
     \code
 	QString string( "bananas" );
 	int i = string.findRev( 'a' );      // i == 5
     \endcode
 */
 
 int QString::findRev( QChar c, int index, bool cs ) const
 {
+#ifdef MACOSX_101
+    return findRev( QString( c ), index, cs );
+#else
     const uint l = length();
     if ( index < 0 )
 	index += l;
     if ( (uint)index >= l )
 	return -1;
     const QChar *end = unicode();
     register const QChar *uc = end + index;
     if ( cs ) {
 	while ( uc >= end && *uc != c )
 	    uc--;
     } else {
 	c = ::lower( c );
 	while ( uc >= end && ::lower( *uc ) != c )
 	    uc--;
     }
     return uc - end;
+#endif
 }
 
 /*!
     \overload
 
     Finds the first occurrence of the string \a str, starting at
     position \a index and searching backwards. If the index is -1, the
     search starts at the last character, if it is -2, at the next to
     last character and so on.
 
     Returns the position of \a str or -1 if \a str could not be found.
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 
     \code
     QString string("bananas");
     int i = string.findRev( "ana" );      // i == 3
     \endcode
 */
 
 int QString::findRev( const QString& str, int index, bool cs ) const
 {
     /*
       See QString::find() for explanations.
     */
     const uint l = length();
     if ( index < 0 )
 	index += l;
     const uint sl = str.length();
     int delta = l-sl;
     if ( index < 0 || index > (int)l || delta < 0 )
 	return -1;
     if ( index > delta )
 	index = delta;
 
+#ifndef MACOSX_101
     if ( sl == 1 )
 	return findRev( *str.unicode(), index, cs );
+#endif
 
     const QChar* needle = str.unicode();
     const QChar* haystack = unicode() + index;
     const QChar* end = unicode();
     const uint sl_minus_1 = sl-1;
     const QChar* n = needle+sl_minus_1;
     const QChar* h = haystack+sl_minus_1;
     uint hashNeedle = 0, hashHaystack = 0, i;
 
     if ( cs ) {
 	for ( i = 0; i < sl; ++i ) {
 	    hashNeedle = ((hashNeedle<<1) + (n-i)->unicode() );
 	    hashHaystack = ((hashHaystack<<1) + (h-i)->unicode() );
 	}
 	hashHaystack -= haystack->unicode();
 
 	while ( haystack >= end ) {
 	    hashHaystack += haystack->unicode();
  	    if ( hashHaystack == hashNeedle
 		 && ucstrncmp( needle, haystack, sl ) == 0 )
 		return haystack-unicode();
 	    --haystack;
 	    REHASH( (haystack+sl)->unicode() );
 	}
     } else {
 	for ( i = 0; i < sl; ++i ) {
 	    hashNeedle = ((hashNeedle<<1)
 			  + ::lower( (n-i)->unicode() ).unicode() );
 	    hashHaystack = ((hashHaystack<<1)
 			    + ::lower( (h-i)->unicode() ).unicode() );
 	}
 	hashHaystack -= ::lower(*haystack).unicode();
 
 	while ( haystack >= end ) {
 	    hashHaystack += ::lower(*haystack).unicode();
 	    if ( hashHaystack == hashNeedle
 		 && ucstrnicmp( needle, haystack, sl ) == 0 )
 		return haystack-unicode();
 	    --haystack;
 	    REHASH( ::lower(*(haystack+sl)).unicode() );
 	}
     }
     return -1;
 }
 
 #undef REHASH
 
 /*!
     \enum QString::SectionFlags
 
     \value SectionDefault Empty fields are counted, leading and
     trailing separators are not included, and the separator is
     compared case sensitively.
 
     \value SectionSkipEmpty Treat empty fields as if they don't exist,
     i.e. they are not considered as far as \e start and \e end are
     concerned.
 
     \value SectionIncludeLeadingSep Include the leading separator (if
     any) in the result string.
 
     \value SectionIncludeTrailingSep Include the trailing separator
     (if any) in the result string.
 
     \value SectionCaseInsensitiveSeps Compare the separator
     case-insensitively.
 
     Any of the last four values can be OR-ed together to form a flag.
 
     \sa section()
 */
 
 /*!
     \fn QString QString::section( QChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
 
     This function returns a section of the string.
 
     This string is treated as a sequence of fields separated by the
     character, \a sep. The returned string consists of the fields from
     position \a start to position \a end inclusive. If \a end is not
     specified, all fields from position \a start to the end of the
     string are included. Fields are numbered 0, 1, 2, etc., counting
     from the left, and -1, -2, etc., counting from right to left.
 
     The \a flags argument can be used to affect some aspects of the
     function's behaviour, e.g. whether to be case sensitive, whether
     to skip empty fields and how to deal with leading and trailing
     separators; see \l{SectionFlags}.
 
     \code
     QString csv( "forename,middlename,surname,phone" );
     QString s = csv.section( ',', 2, 2 );   // s == "surname"
 
     QString path( "/usr/local/bin/myapp" ); // First field is empty
     QString s = path.section( '/', 3, 4 );  // s == "bin/myapp"
     QString s = path.section( '/', 3, 3, SectionSkipEmpty ); // s == "myapp"
     \endcode
 
     If \a start or \a end is negative, we count fields from the right
     of the string, the right-most field being -1, the one from
     right-most field being -2, and so on.
 
     \code
     QString csv( "forename,middlename,surname,phone" );
     QString s = csv.section( ',', -3, -2 );  // s == "middlename,surname"
 
     QString path( "/usr/local/bin/myapp" ); // First field is empty
     QString s = path.section( '/', -1 ); // s == "myapp"
     \endcode
 
     \sa QStringList::split()
 */
 
 /*!
     \overload
 
     This function returns a section of the string.
 
     This string is treated as a sequence of fields separated by the
     string, \a sep. The returned string consists of the fields from
     position \a start to position \a end inclusive. If \a end is not
     specified, all fields from position \a start to the end of the
     string are included. Fields are numbered 0, 1, 2, etc., counting
     from the left, and -1, -2, etc., counting from right to left.
 
     The \a flags argument can be used to affect some aspects of the
     function's behaviour, e.g. whether to be case sensitive, whether
     to skip empty fields and how to deal with leading and trailing
     separators; see \l{SectionFlags}.
 
     \code
     QString data( "forename**middlename**surname**phone" );
     QString s = data.section( "**", 2, 2 ); // s == "surname"
     \endcode
 
     If \a start or \a end is negative, we count fields from the right
     of the string, the right-most field being -1, the one from
     right-most field being -2, and so on.
 
     \code
     QString data( "forename**middlename**surname**phone" );
     QString s = data.section( "**", -3, -2 ); // s == "middlename**surname"
     \endcode
 
     \sa QStringList::split()
 */
 
 QString QString::section( const QString &sep, int start, int end, int flags ) const
 {
     const QChar *uc = unicode();
     if ( !uc )
 	return QString();
     QString _sep = (flags & SectionCaseInsensitiveSeps) ? sep.lower() : sep;
     const QChar *uc_sep = _sep.unicode();
     if(!uc_sep)
 	return QString();
     bool match = FALSE, last_match = TRUE;
 
     //find start
     int n = length(), sep_len = _sep.length();
     const QChar *begin = start < 0 ? uc + n : uc;
     while(start) {
 	match = FALSE;
 	int c = 0;
 	for(const QChar *tmp = start < 0 ? begin - sep_len : begin;
 	    c < sep_len && tmp < uc + n && tmp >= uc; tmp++, c++) {
 	    if(flags & SectionCaseInsensitiveSeps) {
 		if( ::lower( *tmp ) != *(uc_sep + c))
 		    break;
 	    } else {
 		if( *tmp != *(uc_sep + c) )
 		    break;
 	    }
 	    if(c == sep_len - 1) {
 		match = TRUE;
 		break;
 	    }
 	}
 	if(start > 0 && (flags & SectionSkipEmpty) && match && last_match)
 	    match = FALSE;
 	last_match = match;
 
 	if(start < 0) {
 	    if(match) {
 		begin -= sep_len;
 		if(!++start)
 		    break;
 	    } else {
 		if(start == -1 && begin == uc)
 		    break;
 		begin--;
 	    }
 	} else {
 	    if(match) {
 		if(!--start)
 		    break;
 		begin += sep_len;
 	    } else {
 		if(start == 1 && begin == uc + n)
 		    break;
 		begin++;
 	    }
 	}
 	if(begin > uc + n || begin < uc)
 	    return QString();
     }
     if(match && !(flags & SectionIncludeLeadingSep))
 	begin+=sep_len;
     if(begin > uc + n || begin < uc)
 	return QString();
 
     //now find last
     match = FALSE;
     const QChar *last = end < 0 ? uc + n : uc;
     if(end == -1) {
 	int c = 0;
 	for(const QChar *tmp = end < 0 ? last - sep_len : last;
 	    c < sep_len && tmp < uc + n && tmp >= uc; tmp++, c++) {
 	    if(flags & SectionCaseInsensitiveSeps) {
 		if( ::lower( *tmp ) != *(uc_sep + c))
 		    break;
 	    } else {
 		if( *tmp != *(uc_sep + c) )
 		    break;
 	    }
 	    if(c == sep_len - 1) {
 		match = TRUE;
 		break;
 	    }
 	}
     } else {
 	end++;
 	last_match = TRUE;
 	while(end) {
 	    match = FALSE;
 	    int c = 0;
 	    for(const QChar *tmp = end < 0 ? last - sep_len : last;
 		c < sep_len && tmp < uc + n && tmp >= uc; tmp++, c++) {
 		if(flags & SectionCaseInsensitiveSeps) {
 		    if( ::lower( *tmp ) != *(uc_sep + c))
 			break;
 		} else {
 		    if( *tmp != *(uc_sep + c) )
 			break;
 		}
 		if(c == sep_len - 1) {
 		    match = TRUE;
 		    break;
 		}
 	    }
 	    if(end > 0 && (flags & SectionSkipEmpty) && match && last_match)
 		match = FALSE;
 	    last_match = match;
 
 	    if(end < 0) {
 		if(match) {
 		    if(!++end)
 			break;
 		    last -= sep_len;
 		} else {
 		    last--;
 		}
 	    } else {
 		if(match) {
 		    last += sep_len;
 		    if(!--end)
 			break;
 		} else {
 		    last++;
 		}
 	    }
 	    if(last >= uc + n) {
 		last = uc + n;
 		break;
 	    } else if(last < uc) {
 		return QString();
 	    }
 	}
     }
     if(match && !(flags & SectionIncludeTrailingSep))
 	last -= sep_len;
     if(last < uc || last > uc + n || begin >= last)
 	return QString();
 
     //done
     return QString(begin, last - begin);
 }
 
 #ifndef QT_NO_REGEXP
 class section_chunk {
 public:
     section_chunk(int l, QString s) { length = l; string = s; }
     int length;
     QString string;
 };
 /*!
     \overload
 
     This function returns a section of the string.
 
     This string is treated as a sequence of fields separated by the
     regular expression, \a reg. The returned string consists of the
     fields from position \a start to position \a end inclusive. If \a
     end is not specified, all fields from position \a start to the end
     of the string are included. Fields are numbered 0, 1, 2, etc., counting
     from the left, and -1, -2, etc., counting from right to left.
 
     The \a flags argument can be used to affect some aspects of the
     function's behaviour, e.g. whether to be case sensitive, whether
     to skip empty fields and how to deal with leading and trailing
     separators; see \l{SectionFlags}.
 
     \code
     QString line( "forename\tmiddlename  surname \t \t phone" );
     QRegExp sep( "\s+" );
     QString s = line.section( sep, 2, 2 ); // s == "surname"
     \endcode
 
     If \a start or \a end is negative, we count fields from the right
     of the string, the right-most field being -1, the one from
     right-most field being -2, and so on.
 
     \code
     QString line( "forename\tmiddlename  surname \t \t phone" );
     QRegExp sep( "\\s+" );
     QString s = line.section( sep, -3, -2 ); // s == "middlename  surname"
     \endcode
 
     \warning Using this QRegExp version is much more expensive than
     the overloaded string and character versions.
 
     \sa QStringList::split() simplifyWhiteSpace()
 */
 
 QString QString::section( const QRegExp &reg, int start, int end, int flags ) const
 {
     const QChar *uc = unicode();
     if(!uc)
 	return QString();
 
     QRegExp sep(reg);
     sep.setCaseSensitive(!(flags & SectionCaseInsensitiveSeps));
 
     QPtrList<section_chunk> l;
     l.setAutoDelete(TRUE);
     int n = length(), m = 0, last_m = 0, last = 0, last_len = 0;
 
     while( ( m = sep.search( *this, m ) ) != -1 ) {
 	l.append(new section_chunk(last_len, QString(uc + last_m, m - last_m)));
 	last_m = m;
 	last_len = sep.matchedLength();
 	if((m += sep.matchedLength()) >= n) {
 	    last = 1;
 	    break;
 	}
     }
     if(!last)
 	l.append(new section_chunk(last_len, QString(uc + last_m, n - last_m)));
 
     if(start < 0)
 	start = l.count() + start;
     if(end == -1)
 	end = l.count();
     else if(end < 0)
 	end = l.count() + end;
 
     int i = 0;
     QString ret;
     for ( section_chunk *chk=l.first(); chk; chk=l.next(), i++ ) {
 	if((flags & SectionSkipEmpty) && chk->length == (int)chk->string.length()) {
 	    if(i <= start)
 		start++;
 	    end++;
 	}
 	if(i == start) {
 	    ret = (flags & SectionIncludeLeadingSep) ? chk->string : chk->string.mid(chk->length);
 	} else if(i > start) {
 	    ret += chk->string;
 	}
 	if(i == end) {
 	    if((chk=l.next()) && flags & SectionIncludeTrailingSep)
 		ret += chk->string.left(chk->length);
 	    break;
 	}
     }
     return ret;
 }
 #endif
 
 /*!
     \fn QString QString::section( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
 
     \overload
 */
 
 /*!
     \fn QString QString::section( const char *sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
 
     \overload
 */
 
 
 /*!
     Returns the number of times the character \a c occurs in the
     string.
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 
     \code
     QString string( "Trolltech and Qt" );
     int i = string.contains( 't', FALSE );  // i == 3
     \endcode
 */
 
 int QString::contains( QChar c, bool cs ) const
 {
     int count = 0;
     const QChar *uc = unicode();
     if ( !uc )
 	return 0;
     int n = length();
     if ( cs ) {
 	while ( n-- )
 	    if ( *uc++ == c )
 		count++;
     } else {
 	c = ::lower( c );
 	while ( n-- ) {
 	    if ( ::lower( *uc ) == c )
 		count++;
 	    uc++;
 	}
     }
     return count;
 }
 
 /*!
     \overload
 
     Returns the number of times the string \a str occurs in the string.
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 */
 int QString::contains( const char* str, bool cs ) const
 {
     return contains( QString(str), cs );
 }
 
 /*!
     \fn int QString::contains( char c, bool cs ) const
 
     \overload
 */
 
 /*!
     \fn int QString::find( char c, int index, bool cs ) const
 
     \overload
 
     Find character \a c starting from position \a index.
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 */
 
 /*!
     \fn int QString::findRev( char c, int index, bool cs ) const
 
     \overload
 
     Find character \a c starting from position \a index and working
     backwards.
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 */
 
 /*!
     \overload
 
     Returns the number of times \a str occurs in the string.
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 
     This function counts overlapping strings, so in the example below,
     there are two instances of "ana" in "bananas".
 
     \code
     QString str( "bananas" );
     int i = str.contains( "ana" );  // i == 2
     \endcode
 
     \sa findRev()
 */
 
 int QString::contains( const QString &str, bool cs ) const
 {
     if ( isNull() )
 	return 0;
     int count = 0;
     uint skiptable[0x100];
     bm_init_skiptable( str, skiptable, cs );
     int i = -1;
     // use boyer-moore for the ultimate speed experience
     while ( ( i = bm_find( *this, i+1, str, skiptable, cs ) ) != -1 )
 	count++;
     return count;
 }
 
 /*!
     Returns a substring that contains the \a len leftmost characters
     of the string.
 
     The whole string is returned if \a len exceeds the length of the
     string.
 
     \code
 	QString s = "Pineapple";
 	QString t = s.left( 4 );    // t == "Pine"
     \endcode
 
     \sa right(), mid(), isEmpty()
 */
 
 QString QString::left( uint len ) const
 {
     if ( isEmpty() ) {
 	return QString();
     } else if ( len == 0 ) {                    // ## just for 1.x compat:
 	return fromLatin1( "" );
     } else if ( len >= length() ) {
 	return *this;
     } else {
 	QString s( len, TRUE );
 	memcpy( s.d->unicode, d->unicode, len * sizeof(QChar) );
 	s.d->len = len;
 	return s;
     }
 }
 
 /*!
     Returns a string that contains the \a len rightmost characters of
     the string.
 
     If \a len is greater than the length of the string then the whole
     string is returned.
 
     \code
 	QString string( "Pineapple" );
 	QString t = string.right( 5 );   // t == "apple"
     \endcode
 
     \sa left(), mid(), isEmpty()
 */
 
 QString QString::right( uint len ) const
 {
     if ( isEmpty() ) {
 	return QString();
     } else if ( len == 0 ) {                    // ## just for 1.x compat:
 	return fromLatin1( "" );
     } else {
 	uint l = length();
 	if ( len >= l )
 	    return *this;
 	QString s( len, TRUE );
 	memcpy( s.d->unicode, d->unicode+(l-len), len*sizeof(QChar) );
 	s.d->len = len;
 	return s;
     }
 }
 
 /*!
     Returns a string that contains the \a len characters of this
     string, starting at position \a index.
 
     Returns a null string if the string is empty or \a index is out of
     range. Returns the whole string from \a index if \a index + \a len
     exceeds the length of the string.
 
     \code
 	QString s( "Five pineapples" );
 	QString t = s.mid( 5, 4 );                  // t == "pine"
     \endcode
 
     \sa left(), right()
 */
 
 QString QString::mid( uint index, uint len ) const
 {
     uint slen = length();
     if ( isEmpty() || index >= slen ) {
 	return QString();
     } else if ( len == 0 ) {                    // ## just for 1.x compat:
 	return fromLatin1( "" );
     } else {
 	if ( len > slen-index )
 	    len = slen - index;
 	if ( index == 0 && len == slen )
 	    return *this;
 	register const QChar *p = unicode()+index;
 	QString s( len, TRUE );
 	memcpy( s.d->unicode, p, len * sizeof(QChar) );
 	s.d->len = len;
 	return s;
     }
 }
 
 /*!
     Returns a string of length \a width that contains this string
     padded by the \a fill character.
 
     If \a truncate is FALSE and the length of the string is more than
     \a width, then the returned string is a copy of the string.
 
     If \a truncate is TRUE and the length of the string is more than
     \a width, then any characters in a copy of the string after length
     \a width are removed, and the copy is returned.
 
     \code
 	QString s( "apple" );
 	QString t = s.leftJustify( 8, '.' );        // t == "apple..."
     \endcode
 
     \sa rightJustify()
 */
 
 QString QString::leftJustify( uint width, QChar fill, bool truncate ) const
 {
     QString result;
     int len = length();
     int padlen = width - len;
     if ( padlen > 0 ) {
 	result.setLength(len+padlen);
 	if ( len )
 	    memcpy( result.d->unicode, unicode(), sizeof(QChar)*len );
 	QChar* uc = result.d->unicode + len;
 	while (padlen--)
 	    *uc++ = fill;
     } else {
 	if ( truncate )
 	    result = left( width );
 	else
 	    result = *this;
     }
     return result;
 }
 
 /*!
     Returns a string of length \a width that contains the \a fill
     character followed by the string.
 
     If \a truncate is FALSE and the length of the string is more than
     \a width, then the returned string is a copy of the string.
 
     If \a truncate is TRUE and the length of the string is more than
     \a width, then the resulting string is truncated at position \a
     width.
 
     \code
 	QString string( "apple" );
 	QString t = string.rightJustify( 8, '.' );  // t == "...apple"
     \endcode
 
     \sa leftJustify()
 */
 
 QString QString::rightJustify( uint width, QChar fill, bool truncate ) const
 {
     QString result;
     int len = length();
     int padlen = width - len;
     if ( padlen > 0 ) {
 	result.setLength( len+padlen );
 	QChar* uc = result.d->unicode;
 	while (padlen--)
 	    *uc++ = fill;
 	if ( len )
 	    memcpy( uc, unicode(), sizeof(QChar)*len );
     } else {
 	if ( truncate )
 	    result = left( width );
 	else
 	    result = *this;
     }
     return result;
 }
 
 /*!
     Returns a lowercase copy of the string.
 
     \code
 	QString string( "TROlltECH" );
 	str = string.lower();   // str == "trolltech"
     \endcode
 
     \sa upper()
 */
 
 QString QString::lower() const
 {
-    QString s(*this);
-    int l=length();
-    if ( l ) {
-	s.real_detach(); // could do this only when we find a change
-	register QChar *p=s.d->unicode;
-	if ( p ) {
-	    while ( l-- ) {
+    int l = length();
+    register QChar *p = d->unicode;
+    while ( l ) {
+	if ( *p != ::lower(*p) ) {
+	    QString s( *this );
+	    s.real_detach();
+	    p = s.d->unicode + ( p - d->unicode );
+	    while ( l ) {
 		*p = ::lower( *p );
+		l--;
 		p++;
 	    }
+	    return s;
 	}
+	l--;
+	p++;
     }
-    return s;
+    return *this;
 }
 
 /*!
     Returns an uppercase copy of the string.
 
     \code
 	QString string( "TeXt" );
 	str = string.upper();     // t == "TEXT"
     \endcode
 
     \sa lower()
 */
 
 QString QString::upper() const
 {
-    QString s(*this);
-    int l=length();
-    if ( l ) {
-	s.real_detach(); // could do this only when we find a change
-	register QChar *p=s.d->unicode;
-	if ( p ) {
-	    while ( l-- ) {
+    int l = length();
+    register QChar *p = d->unicode;
+    while ( l ) {
+	if ( *p != ::upper(*p) ) {
+	    QString s( *this );
+	    s.real_detach();
+	    p = s.d->unicode + ( p - d->unicode );
+	    while ( l ) {
 		*p = ::upper( *p );
+		l--;
 		p++;
 	    }
+	    return s;
 	}
+	l--;
+	p++;
     }
-    return s;
+    return *this;
 }
 
 
 /*!
     Returns a string that has whitespace removed from the start and
     the end.
 
     Whitespace means any character for which QChar::isSpace() returns
     TRUE. This includes Unicode characters with decimal values 9
     (TAB), 10 (LF), 11 (VT), 12 (FF), 13 (CR) and 32 (Space), and may
     also include other Unicode characters.
 
     \code
 	QString string = "   white space   ";
 	QString s = string.stripWhiteSpace();       // s == "white space"
     \endcode
 
     \sa simplifyWhiteSpace()
 */
 
 QString QString::stripWhiteSpace() const
 {
     if ( isEmpty() )                            // nothing to do
 	return *this;
     register const QChar *s = unicode();
     if ( !s->isSpace() && !s[length()-1].isSpace() )
 	return *this;
 
     int start = 0;
     int end = length() - 1;
     while ( start<=end && s[start].isSpace() )  // skip white space from start
 	start++;
     if ( start <= end ) {                          // only white space
 	while ( end && s[end].isSpace() )           // skip white space from end
 	    end--;
     }
     int l = end - start + 1;
     if ( l <= 0 )
     	return QString::fromLatin1("");
 
     QString result( l, TRUE );
     memcpy( result.d->unicode, &s[start], sizeof(QChar)*l );
     result.d->len = l;
     return result;
 }
 
 
 /*!
     Returns a string that has whitespace removed from the start and
     the end, and which has each sequence of internal whitespace
     replaced with a single space.
 
     Whitespace means any character for which QChar::isSpace() returns
     TRUE. This includes Unicode characters with decimal values 9
     (TAB), 10 (LF), 11 (VT), 12 (FF), 13 (CR), and 32 (Space).
 
     \code
 	QString string = "  lots\t of\nwhite    space ";
 	QString t = string.simplifyWhiteSpace();
 	// t == "lots of white space"
     \endcode
 
     \sa stripWhiteSpace()
 */
 
 QString QString::simplifyWhiteSpace() const
 {
     if ( isEmpty() )
 	return *this;
     QString result;
     result.setLength( length() );
     const QChar *from = unicode();
     const QChar *fromend = from+length();
     int outc=0;
     QChar *to   = result.d->unicode;
     for (;;) {
 	while ( from!=fromend && from->isSpace() )
 	    from++;
 	while ( from!=fromend && !from->isSpace() )
 	    to[outc++] = *from++;
 	if ( from!=fromend )
 	    to[outc++] = ' ';
 	else
 	    break;
     }
     if ( outc > 0 && to[outc-1] == ' ' )
 	outc--;
     result.truncate( outc );
     return result;
 }
 
 
 /*!
     Inserts \a s into the string at position \a index.
 
     If \a index is beyond the end of the string, the string is
     extended with spaces to length \a index and \a s is then appended
     and returns a reference to the string.
 
     \code
 	QString string( "I like fish" );
 	str = string.insert( 2, "don't " );
 	// str == "I don't like fish"
     \endcode
 
     \sa remove(), replace()
 */
 
 QString &QString::insert( uint index, const QString &s )
 {
     // the sub function takes care of &s == this case.
     return insert( index, s.unicode(), s.length() );
 }
 
 /*!
     \overload
 
-    Inserts the character in \a s into the string at position \a index
-    \a len number of times and returns a reference to the string.
+    Inserts the first \a len characters in \a s into the string at
+    position \a index and returns a reference to the string.
 */
 
 QString &QString::insert( uint index, const QChar* s, uint len )
 {
     if ( len == 0 )
 	return *this;
     uint olen = length();
     int nlen = olen + len;
 
     if ( s >= d->unicode && (uint)(s - d->unicode) < d->maxl ) {
 	// Part of me - take a copy.
 	QChar *tmp = QT_ALLOC_QCHAR_VEC( len );
 	memcpy(tmp,s,len*sizeof(QChar));
 	insert(index,tmp,len);
 	QT_DELETE_QCHAR_VEC( tmp );
 	return *this;
     }
 
     if ( index >= olen ) {                      // insert after end of string
 	setLength( len + index );
 	int n = index - olen;
 	QChar* uc = d->unicode+olen;
 	while (n--)
 	    *uc++ = ' ';
 	memcpy( d->unicode+index, s, sizeof(QChar)*len );
     } else {                                    // normal insert
 	setLength( nlen );
 	memmove( d->unicode + index + len, unicode() + index,
 		 sizeof(QChar) * (olen - index) );
 	memcpy( d->unicode + index, s, sizeof(QChar) * len );
     }
     return *this;
 }
 
 /*!
     \overload
 
     Insert \a c into the string at position \a index and returns a
     reference to the string.
 
     If \a index is beyond the end of the string, the string is
     extended with spaces (ASCII 32) to length \a index and \a c is
     then appended.
 */
 
 QString &QString::insert( uint index, QChar c ) // insert char
 {
     QString s( c );
     return insert( index, s );
 }
 
 /*!
     \fn QString& QString::insert( uint index, char c )
 
     \overload
 
     Insert character \a c at position \a index.
 */
 
 /*!
     \fn QString &QString::prepend( const QString &s )
 
     Inserts \a s at the beginning of the string and returns a
     reference to the string.
 
     Equivalent to insert(0, \a s).
 
     \code
 	QString string = "42";
 	string.prepend( "The answer is " );
 	// string == "The answer is 42"
     \endcode
 
     \sa insert()
 */
 
 /*!
     \fn QString& QString::prepend( char ch )
 
     \overload
 
     Inserts \a ch at the beginning of the string and returns a
     reference to the string.
 
     Equivalent to insert(0, \a ch).
 
     \sa insert()
 */
 
 /*!
     \fn QString& QString::prepend( QChar ch )
 
     \overload
 
     Inserts \a ch at the beginning of the string and returns a
     reference to the string.
 
     Equivalent to insert(0, \a ch).
 
     \sa insert()
 */
 
 /*! \fn QString& QString::prepend( const QByteArray &s )
   \overload
 
   Inserts \a s at the beginning of the string and returns a reference to the string.
 
   Equivalent to insert(0, \a s).
 
   \sa insert()
  */
 
+/*! \fn QString& QString::prepend( const std::string &s )
+  \overload
+
+  Inserts \a s at the beginning of the string and returns a reference to the string.
+
+  Equivalent to insert(0, \a s).
+
+  \sa insert()
+ */
+
 /*!
   \overload
 
   Inserts \a s at the beginning of the string and returns a reference to the string.
 
   Equivalent to insert(0, \a s).
 
   \sa insert()
  */
 QString &QString::prepend( const char *s )
 {
     return insert( 0, QString(s) );
 }
 
 /*!
     Removes \a len characters from the string starting at position \a
     index, and returns a reference to the string.
 
     If \a index is beyond the length of the string, nothing happens.
     If \a index is within the string, but \a index + \a len is beyond
     the end of the string, the string is truncated at position \a
     index.
 
     \code
 	QString string( "Montreal" );
 	string.remove( 1, 4 );      // string == "Meal"
     \endcode
 
     \sa insert(), replace()
 */
 
 QString &QString::remove( uint index, uint len )
 {
     uint olen = length();
     if ( index >= olen  ) {
 	// range problems
     } else if ( index + len >= olen ) {  // index ok
 	setLength( index );
     } else if ( len != 0 ) {
 	real_detach();
 	memmove( d->unicode+index, d->unicode+index+len,
 		 sizeof(QChar)*(olen-index-len) );
 	setLength( olen-len );
     }
     return *this;
 }
 
 /*! \overload
 
     Removes every occurrence of the character \a c in the string.
     Returns a reference to the string.
 
     This is the same as replace(\a c, "").
 */
 QString &QString::remove( QChar c )
 {
     int i = 0;
     while ( i < (int) length() ) {
 	if ( constref(i) == c ) {
 	    remove( i, 1 );
 	} else {
 	    i++;
 	}
     }
     return *this;
 }
 
 /*! \overload
 
     \fn QString &QString::remove( char c )
 
     Removes every occurrence of the character \a c in the string.
     Returns a reference to the string.
 
     This is the same as replace(\a c, "").
 */
 
 /*! \overload
 
     Removes every occurrence of \a str in the string. Returns a
     reference to the string.
 
     This is the same as replace(\a str, "").
 */
 QString &QString::remove( const QString & str )
 {
     int index = 0;
     if ( !str.isEmpty() ) {
 	while ( (index = find(str, index)) != -1 )
 	    remove( index, str.length() );
     }
     return *this;
 }
 
 /*! \overload
 
   Replaces every occurrence of \a c1 with the char \a c2.
   Returns a reference to the string.
 */
 QString &QString::replace( QChar c1, QChar c2 )
 {
      real_detach();
      uint i = 0;
      while ( i < d->len ) {
 	  if ( d->unicode[i] == c1 )
 	       d->unicode[i] = c2;
 	  i++;
      }
      return *this;
 }
 
 
 #ifndef QT_NO_REGEXP_CAPTURE
 
 /*! \overload
 
     Removes every occurrence of the regular expression \a rx in the
     string. Returns a reference to the string.
 
     This is the same as replace(\a rx, "").
 */
 
 QString &QString::remove( const QRegExp & rx )
 {
     return replace( rx, QString::null );
 }
 
 #endif
 
 /*! \overload
 
     Removes every occurrence of \a str in the string. Returns a
     reference to the string.
 */
 QString &QString::remove( const char *str )
 {
     return remove( QString::fromLatin1(str) );
 }
 
 /*!
     Replaces \a len characters from the string with \a s, starting at
     position \a index, and returns a reference to the string.
 
     If \a index is beyond the length of the string, nothing is deleted
     and \a s is appended at the end of the string. If \a index is
     valid, but \a index + \a len is beyond the end of the string,
     the string is truncated at position \a index, then \a s is
     appended at the end.
 
     \code
 	QString string( "Say yes!" );
 	string = string.replace( 4, 3, "NO" );
 	// string == "Say NO!"
     \endcode
 
     \sa insert(), remove()
 */
 
 QString &QString::replace( uint index, uint len, const QString &s )
 {
     return replace( index, len, s.unicode(), s.length() );
 }
 
 /*! \overload
 
     This is the same as replace(\a index, \a len, QString(\a c)).
 */
 QString &QString::replace( uint index, uint len, QChar c )
 {
     return replace( index, len, &c, 1 );
 }
 
 /*! \overload
     \fn QString &QString::replace( uint index, uint len, char c )
 
     This is the same as replace(\a index, \a len, QChar(\a c)).
 */
 
 /*!
     \overload
 
     Replaces \a len characters with \a slen characters of QChar data
     from \a s, starting at position \a index, and returns a reference
     to the string.
 
     \sa insert(), remove()
 */
 
 QString &QString::replace( uint index, uint len, const QChar* s, uint slen )
 {
     real_detach();
     if ( len == slen && index + len <= length() ) {
 	// Optimized common case: replace without size change
 	memcpy( d->unicode+index, s, len * sizeof(QChar) );
     } else if ( s >= d->unicode && (uint)(s - d->unicode) < d->maxl ) {
 	// Part of me - take a copy.
 	QChar *tmp = QT_ALLOC_QCHAR_VEC( slen );
 	memcpy( tmp, s, slen * sizeof(QChar) );
 	replace( index, len, tmp, slen );
 	QT_DELETE_QCHAR_VEC( tmp );
     } else {
 	remove( index, len );
 	insert( index, s, slen );
     }
     return *this;
 }
 
 /*! \overload
 
     Replaces every occurrence of the character \a c in the string
     with \a after. Returns a reference to the string.
 
     Example:
     \code
     QString s = "a,b,c";
     s.replace( QChar(','), " or " );
     // s == "a or b or c"
     \endcode
 */
 QString &QString::replace( QChar c, const QString & after )
 {
     return replace( QString( c ), after );
 }
 
 /*! \overload
     \fn QString &QString::replace( char c, const QString & after )
 
     Replaces every occurrence of the character \a c in the string
     with \a after. Returns a reference to the string.
 */
 
 /*! \overload
 
     Replaces every occurrence of the string \a before in the string
     with the string \a after. Returns a reference to the string.
 
     Example:
     \code
     QString s = "Greek is Greek";
     s.replace( "Greek", "English" );
     // s == "English is English"
     \endcode
 */
 QString &QString::replace( const QString & before, const QString & after )
 {
     if ( before == after || isNull() )
 	return *this;
 
     real_detach();
 
     int index = 0;
     uint skiptable[256];
     bm_init_skiptable( before, skiptable, TRUE );
     const int bl = before.length();
     const int al = after.length();
 
     if ( bl == al ) {
 	if ( bl ) {
 	    const QChar *auc = after.unicode();
 	    while( (index = bm_find(*this, index, before, skiptable, TRUE) ) != -1 ) {
 		memcpy( d->unicode+index, auc, al*sizeof(QChar) );
 		index += bl;
 	    }
 	}
     } else if ( al < bl ) {
 	const QChar *auc = after.unicode();
 	uint to = 0;
 	uint movestart = 0;
 	uint num = 0;
 	while( (index = bm_find(*this, index, before, skiptable, TRUE) ) != -1 ) {
 	    if ( num ) {
 		int msize = index - movestart;
 		if ( msize > 0 ) {
 		    memmove( d->unicode + to, d->unicode + movestart, msize*sizeof(QChar) );
 		    to += msize;
 		}
 	    } else {
 		to = index;
 	    }
 	    if ( al ) {
 		memcpy( d->unicode+to, auc, al*sizeof(QChar) );
 		to += al;
 	    }
 	    index += bl;
 	    movestart = index;
 	    num++;
 	}
 	if ( num ) {
 	    int msize = d->len - movestart;
 	    if ( msize > 0 )
 		memmove( d->unicode + to, d->unicode + movestart, msize*sizeof(QChar) );
 	    setLength( d->len - num*(bl-al) );
 	}
     } else {
 	// the most complex case. We don't want to loose performance by doing repeated
 	// copies and reallocs of the string.
 	while( index != -1 ) {
 	    uint indices[4096];
 	    uint pos = 0;
 	    while( pos < 4095 ) {
 		index = bm_find(*this, index, before, skiptable, TRUE);
 		if ( index == -1 )
 		    break;
 		indices[pos++] = index;
 		index += bl;
 		// avoid infinite loop
 		if ( !bl )
 		    index++;
 	    }
 	    if ( !pos )
 		break;
 
 	    // we have a table of replacement positions, use them for fast replacing
 	    int adjust = pos*(al-bl);
 	    // index has to be adjusted in case we get back into the loop above.
 	    if ( index != -1 )
 		index += adjust;
 	    uint newlen = d->len + adjust;
 	    int moveend = d->len;
 	    if ( newlen > d->len )
 		setLength( newlen );
 
 	    while( pos ) {
 		pos--;
 		int movestart = indices[pos] + bl;
 		int insertstart = indices[pos] + pos*(al-bl);
 		int moveto = insertstart + al;
 		memmove( d->unicode + moveto, d->unicode + movestart, (moveend - movestart)*sizeof(QChar) );
 		memcpy( d->unicode + insertstart, after.unicode(), al*sizeof(QChar) );
 		moveend = movestart-bl;
 	    }
 	}
     }
     return *this;
 }
 
 #ifndef QT_NO_REGEXP_CAPTURE
 /*! \overload
 
   Replaces every occurrence of the regexp \a rx in the string with \a str.
   Returns a reference to the string. For example:
   \code
     QString s = "banana";
     s.replace( QRegExp("an"), "" );
     // s == "ba"
   \endcode
 
   For regexps containing \link qregexp.html#capturing-text capturing
   parentheses \endlink, occurrences of <b>\\1</b>, <b>\\2</b>, ...,
   in \a str are replaced with \a{rx}.cap(1), cap(2), ...
 
   \code
     QString t = "A <i>bon mot</i>.";
     t.replace( QRegExp("<i>([^<]*)</i>"), "\\emph{\\1}" );
     // t == "A \\emph{bon mot}."
   \endcode
 
   \sa find(), findRev(), QRegExp::cap()
 */
 
 QString &QString::replace( const QRegExp &rx, const QString &str )
 {
     if ( isNull() )
 	return *this;
 
     real_detach();
 
     QRegExp rx2 = rx;
     int index = 0;
     int numCaptures = rx2.numCaptures();
     int al = str.length();
     QRegExp::CaretMode caretMode = QRegExp::CaretAtZero;
 
     if ( numCaptures > 0 ) {
 	if ( numCaptures > 9 )
 	    numCaptures = 9;
 
 	const QChar *uc = str.unicode();
 	int numBackRefs = 0;
 
 	for ( int i = 0; i < al - 1; i++ ) {
 	    if ( uc[i] == '\\' ) {
 		int no = uc[i + 1].digitValue();
 		if ( no > 0 && no <= numCaptures )
 		    numBackRefs++;
 	    }
 	}
 
 	/*
 	  This is the harder case where we have back-references. We
 	  don't try to optimize it.
 	*/
 	if ( numBackRefs > 0 ) {
 	    int *capturePositions = new int[numBackRefs];
 	    int *captureNumbers = new int[numBackRefs];
 	    int j = 0;
 
 	    for ( int i = 0; i < al - 1; i++ ) {
 		if ( uc[i] == '\\' ) {
 		    int no = uc[i + 1].digitValue();
 		    if ( no > 0 && no <= numCaptures ) {
 			capturePositions[j] = i;
 			captureNumbers[j] = no;
 			j++;
 		    }
 		}
 	    }
 
 	    while ( index <= (int)length() ) {
 		index = rx2.search( *this, index, caretMode );
 		if ( index == -1 )
 		    break;
 
 		QString str2 = str;
 		for ( j = numBackRefs - 1; j >= 0; j-- )
 		    str2.replace( capturePositions[j], 2,
 				  rx2.cap(captureNumbers[j]) );
 
 		replace( index, rx2.matchedLength(), str2 );
 		index += str2.length();
 
 		if ( rx2.matchedLength() == 0 ) {
 		    // avoid infinite loop on 0-length matches (e.g., [a-z]*)
 		    index++;
 		} else if ( index == 0 ) {
 		    caretMode = QRegExp::CaretWontMatch;
 		}
 	    }
 	    delete[] capturePositions;
 	    delete[] captureNumbers;
 	    return *this;
 	}
     }
 
     /*
       This is the simple and optimized case where we don't have
       back-references.
     */
     while ( index != -1 ) {
 	struct {
 	    int pos;
 	    int length;
 	} replacements[2048];
 
 	uint pos = 0;
 	int adjust = 0;
 	while( pos < 2047 ) {
 	    index = rx2.search( *this, index, caretMode );
 	    if ( index == -1 )
 		break;
 	    int ml = rx2.matchedLength();
 	    replacements[pos].pos = index;
 	    replacements[pos++].length = ml;
 	    index += ml;
 	    adjust += al - ml;
 	    // avoid infinite loop
 	    if ( !ml )
 		index++;
 	}
 	if ( !pos )
 	    break;
 	replacements[pos].pos = d->len;
 	uint newlen = d->len + adjust;
 
 	// to continue searching at the right position after we did
 	// the first round of replacements
 	if ( index != -1 )
 	    index += adjust;
 	QChar *newuc = QT_ALLOC_QCHAR_VEC( newlen + 1 );
 	QChar *uc = newuc;
 	int copystart = 0;
 	uint i = 0;
 	while( i < pos ) {
 	    int copyend = replacements[i].pos;
 	    int size = copyend - copystart;
 	    memcpy( uc, d->unicode + copystart, size*sizeof(QChar) );
 	    uc += size;
 	    memcpy( uc, str.unicode(), al*sizeof( QChar ) );
 	    uc += al;
 	    copystart = copyend + replacements[i].length;
 	    i++;
 	}
 	memcpy( uc, d->unicode + copystart,
 		(d->len - copystart) * sizeof(QChar) );
 	QT_DELETE_QCHAR_VEC( d->unicode );
 	d->unicode = newuc;
 	d->len = newlen;
 	d->maxl = newlen + 1;
 	d->setDirty();
 	caretMode = QRegExp::CaretWontMatch;
     }
     return *this;
 }
 #endif
 
 #ifndef QT_NO_REGEXP
 /*!
     Finds the first match of the regular expression \a rx, starting
     from position \a index. If \a index is -1, the search starts at
     the last character; if -2, at the next to last character and so
     on. (See findRev() for searching backwards.)
 
     Returns the position of the first match of \a rx or -1 if no match
     was found.
 
     \code
 	QString string( "bananas" );
 	int i = string.find( QRegExp("an"), 0 );    // i == 1
     \endcode
 
     \sa findRev() replace() contains()
 */
 
 int QString::find( const QRegExp &rx, int index ) const
 {
     return rx.search( *this, index );
 }
 
 /*!
     \overload
 
     Finds the first match of the regexp \a rx, starting at position \a
     index and searching backwards. If the index is -1, the search
     starts at the last character, if it is -2, at the next to last
     character and so on. (See findRev() for searching backwards.)
 
     Returns the position of the match or -1 if no match was found.
 
     \code
 	QString string( "bananas" );
 	int i = string.findRev( QRegExp("an") );      // i == 3
     \endcode
 
     \sa find()
 */
 
 int QString::findRev( const QRegExp &rx, int index ) const
 {
     return rx.searchRev( *this, index );
 }
 
 /*!
     \overload
 
     Returns the number of times the regexp, \a rx, matches in the
     string.
 
     This function counts overlapping matches, so in the example below,
     there are four instances of "ana" or "ama".
 
     \code
 	QString str = "banana and panama";
 	QRegExp rxp = QRegExp( "a[nm]a", TRUE, FALSE );
 	int i = str.contains( rxp );    // i == 4
     \endcode
 
     \sa find() findRev()
 */
 
 int QString::contains( const QRegExp &rx ) const
 {
     int count = 0;
     int index = -1;
     int len = length();
     while ( index < len - 1 ) {                 // count overlapping matches
 	index = rx.search( *this, index + 1 );
 	if ( index == -1 )
 	    break;
 	count++;
     }
     return count;
 }
 
 #endif //QT_NO_REGEXP
 
 static bool ok_in_base( QChar c, int base )
 {
     if ( base <= 10 )
 	return c.isDigit() && c.digitValue() < base;
     else
 	return c.isDigit() || (c >= 'a' && c < char('a'+base-10))
 			   || (c >= 'A' && c < char('A'+base-10));
 }
 
 /*!
     Returns the string converted to a \c long value to the base \a
     base, which is 10 by default and must be between 2 and 36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \sa number()
 */
 
 long QString::toLong( bool *ok, int base ) const
 {
     const QChar *p = unicode();
-    long val = 0;
+    ulong val = 0;
     int l = length();
-    const long max_mult = INT_MAX / base;
+    const ulong max_mult = LONG_MAX / base;
     bool is_ok = FALSE;
     int neg = 0;
     if ( !p )
 	goto bye;
     while ( l && p->isSpace() )                 // skip leading space
 	l--,p++;
     if ( !l )
 	goto bye;
     if ( *p == '-' ) {
 	l--;
 	p++;
 	neg = 1;
     } else if ( *p == '+' ) {
 	l--;
 	p++;
     }
 
     // NOTE: toULong() code is similar
     if ( !l || !ok_in_base(*p,base) )
 	goto bye;
     while ( l && ok_in_base(*p,base) ) {
 	l--;
 	int dv;
 	if ( p->isDigit() ) {
 	    dv = p->digitValue();
 	} else {
 	    if ( *p >= 'a' && *p <= 'z' )
 		dv = *p - 'a' + 10;
 	    else
 		dv = *p - 'A' + 10;
 	}
 	if ( val > max_mult ||
-	    (val == max_mult && dv > (INT_MAX % base) + neg) )
+	    (val == max_mult && dv > (LONG_MAX % base) + neg) )
 	    goto bye;
 	val = base * val + dv;
 	p++;
     }
-    if ( neg )
-	val = -val;
     while ( l && p->isSpace() )                 // skip trailing space
-	l--,p++;
+	l--, p++;
     if ( !l )
 	is_ok = TRUE;
 bye:
     if ( ok )
 	*ok = is_ok;
-    return is_ok ? val : 0;
+    return is_ok ? ( neg ? -( (long) val ) : (long) val ) : 0L;
 }
 
 /*!
     Returns the string converted to an \c {unsigned long} value to the
     base \a base, which is 10 by default and must be between 2 and 36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \sa number()
 */
 
 ulong QString::toULong( bool *ok, int base ) const
 {
     const QChar *p = unicode();
     ulong val = 0;
     int l = length();
-    const ulong max_mult = UINT_MAX / base;
+    const ulong max_mult = ULONG_MAX / base;
     bool is_ok = FALSE;
     if ( !p )
 	goto bye;
     while ( l && p->isSpace() )                 // skip leading space
 	l--,p++;
     if ( !l )
 	goto bye;
     if ( *p == '+' )
 	l--,p++;
 
     // NOTE: toLong() code is similar
     if ( !l || !ok_in_base(*p,base) )
 	goto bye;
     while ( l && ok_in_base(*p,base) ) {
 	l--;
 	uint dv;
 	if ( p->isDigit() ) {
 	    dv = p->digitValue();
 	} else {
 	    if ( *p >= 'a' && *p <= 'z' )
 		dv = *p - 'a' + 10;
 	    else
 		dv = *p - 'A' + 10;
 	}
-	if ( val > max_mult || (val == max_mult && dv > UINT_MAX % base) )
+	if ( val > max_mult || (val == max_mult && dv > ULONG_MAX % base) )
 	    goto bye;
 	val = base * val + dv;
 	p++;
     }
 
     while ( l && p->isSpace() )                 // skip trailing space
 	l--,p++;
     if ( !l )
 	is_ok = TRUE;
 bye:
     if ( ok )
 	*ok = is_ok;
     return is_ok ? val : 0;
 }
 
 /*!
     Returns the string converted to a \c short value to the base \a
     base, which is 10 by default and must be between 2 and 36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 */
 
 short QString::toShort( bool *ok, int base ) const
 {
     long v = toLong( ok, base );
-    if ( ok && *ok && (v < -32768 || v > 32767) ) {
+    if ( ok && *ok && (v < SHRT_MIN || v > SHRT_MAX) ) {
 	*ok = FALSE;
 	v = 0;
     }
     return (short)v;
 }
 
 /*!
     Returns the string converted to an \c {unsigned short} value to
     the base \a base, which is 10 by default and must be between 2 and
     36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 */
 
 ushort QString::toUShort( bool *ok, int base ) const
 {
     ulong v = toULong( ok, base );
-    if ( ok && *ok && (v > 65535) ) {
+    if ( ok && *ok && (v > USHRT_MAX) ) {
 	*ok = FALSE;
 	v = 0;
     }
     return (ushort)v;
 }
 
 
 /*!
     Returns the string converted to an \c int value to the base \a
     base, which is 10 by default and must be between 2 and 36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \code
 	QString str( "FF" );
 	bool ok;
 	int hex = str.toInt( &ok, 16 );     // hex == 255, ok == TRUE
 	int dec = str.toInt( &ok, 10 );     // dec == 0, ok == FALSE
     \endcode
 
     \sa number()
 */
 
 int QString::toInt( bool *ok, int base ) const
 {
-    return (int)toLong( ok, base );
+    long v = toLong( ok, base );
+    if ( ok && *ok && (v < INT_MIN || v > INT_MAX) ) {
+	*ok = FALSE;
+	v = 0;
+    }
+    return (int)v;
 }
 
 /*!
     Returns the string converted to an \c{unsigned int} value to the
     base \a base, which is 10 by default and must be between 2 and 36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \sa number()
 */
 
 uint QString::toUInt( bool *ok, int base ) const
 {
-    return (uint)toULong( ok, base );
+    ulong v = toULong( ok, base );
+    if ( ok && *ok && (v > UINT_MAX) ) {
+	*ok = FALSE;
+	v = 0;
+    }
+    return (uint)v;
 }
 
 /*!
     Returns the string converted to a \c double value.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \code
 	QString string( "1234.56" );
 	double a = string.toDouble();   // a == 1234.56
     \endcode
 
     \sa number()
 */
 
 double QString::toDouble( bool *ok ) const
 {
     char *end;
 
     const char *a = latin1();
     double val = strtod( a ? a : "", &end );
     if ( ok )
-	*ok = ( a && *a && (end == 0 || (end - a) == (int)length()) );
+	*ok = ( a && *a && (end == 0 || *end == '\0') );
     return val;
 }
 
 /*!
     Returns the string converted to a \c float value.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \sa number()
 */
 
 float QString::toFloat( bool *ok ) const
 {
     return (float)toDouble( ok );
 }
 
 
 /*!
     Sets the string to the printed value of \a n in base \a base and
     returns a reference to the string.
 
     The base is 10 by default and must be between 2 and 36.
 
     \code
 	QString string;
 	string = string.setNum( 1234 );     // string == "1234"
     \endcode
 */
 
 QString &QString::setNum( long n, int base )
 {
 #if defined(QT_CHECK_RANGE)
     if ( base < 2 || base > 36 ) {
 	qWarning( "QString::setNum: Invalid base %d", base );
 	base = 10;
     }
 #endif
     char   charbuf[65*sizeof(QChar)];
     QChar *buf = (QChar*)charbuf;
     QChar *p = &buf[64];
     int  len = 0;
     bool neg;
     if ( n < 0 ) {
 	neg = TRUE;
-	if ( n == INT_MIN ) {
+	if ( n == LONG_MIN ) {
 	    // Cannot always negate this special case
 	    QString s1, s2;
-	    s1.setNum(n/base);
-	    s2.setNum((-(n+base))%base);
+	    s1.setNum(n/base, base );
+	    s2.setNum((-(n+base))%base, base );
 	    *this = s1 + s2;
 	    return *this;
 	}
 	n = -n;
     } else {
 	neg = FALSE;
     }
     do {
 	*--p = "0123456789abcdefghijklmnopqrstuvwxyz"[((int)(n%base))];
 	n /= base;
 	++len;
     } while ( n );
     if ( neg ) {
 	*--p = '-';
 	++len;
     }
     return setUnicode( p, len );
 }
 
 /*!
     \overload
 
     Sets the string to the printed value of \a n in base \a base and
     returns a reference to the string.
 
     The base is 10 by default and must be between 2 and 36.
 */
 
 QString &QString::setNum( ulong n, int base )
 {
 #if defined(QT_CHECK_RANGE)
     if ( base < 2 || base > 36 ) {
 	qWarning( "QString::setNum: Invalid base %d", base );
 	base = 10;
     }
 #endif
     char   charbuf[65*sizeof(QChar)];
     QChar *buf = (QChar*)charbuf;
     QChar *p = &buf[64];
     int len = 0;
     do {
 	*--p = "0123456789abcdefghijklmnopqrstuvwxyz"[((int)(n%base))];
 	n /= base;
 	len++;
     } while ( n );
     return setUnicode(p,len);
 }
 
 /*!
     \fn QString &QString::setNum( int n, int base )
 
     \overload
 
     Sets the string to the printed value of \a n in base \a base and
     returns a reference to the string.
 
     The base is 10 by default and must be between 2 and 36.
 */
 
 /*!
     \fn QString &QString::setNum( uint n, int base )
 
     \overload
 
     Sets the string to the printed value of \a n in base \a base and
     returns a reference to the string.
 
     The base is 10 by default and must be between 2 and 36.
 */
 
 /*!
     \fn QString &QString::setNum( short n, int base )
 
     \overload
 
     Sets the string to the printed value of \a n in base \a base and
     returns a reference to the string.
 
     The base is 10 by default and must be between 2 and 36.
 */
 
 /*!
     \fn QString &QString::setNum( ushort n, int base )
 
     \overload
 
     Sets the string to the printed value of \a n in base \a base and
     returns a reference to the string.
 
     The base is 10 by default and must be between 2 and 36.
 */
 
 /*!
     \overload
 
     Sets the string to the printed value of \a n, formatted in format
     \a f with precision \a prec, and returns a reference to the
     string.
 
     The format \a f can be 'f', 'F', 'e', 'E', 'g' or 'G'. See \link
     #arg-formats arg \endlink() for an explanation of the formats.
 */
 
 QString &QString::setNum( double n, char f, int prec )
 {
 #if defined(QT_CHECK_RANGE)
     if ( !(f=='f' || f=='F' || f=='e' || f=='E' || f=='g' || f=='G') ) {
 	qWarning( "QString::setNum: Invalid format char '%c'", f );
 	f = 'f';
     }
 #endif
     char format[20];
     char *fs = format; // generate format string: %.<prec>l<f>
     *fs++ = '%';
     if ( prec >= 0 ) {
 	if ( prec > 99 ) // rather than crash in sprintf()
 	    prec = 99;
 	*fs++ = '.';
 	if ( prec >= 10 ) {
 	    *fs++ = prec / 10 + '0';
 	    *fs++ = prec % 10 + '0';
 	} else {
 	    *fs++ = prec + '0';
 	}
     }
     *fs++ = 'l';
     *fs++ = f;
     *fs = '\0';
 #ifndef QT_NO_SPRINTF
     sprintf( format, n );
     return *this;
 #else
     char buf[512];
     ::sprintf( buf, format, n );        // snprintf is unfortunately not portable
     return setLatin1(buf);
 #endif
 }
 
 /*!
     \fn QString &QString::setNum( float n, char f, int prec )
 
     \overload
 
     Sets the string to the printed value of \a n, formatted in format
     \a f with precision \a prec, and returns a reference to the
     string.
 
     The format \a f can be 'f', 'F', 'e', 'E', 'g' or 'G'. See \link
     #arg-formats arg \endlink() for an explanation of the formats.
 */
 
 
 /*!
     A convenience function that returns a string equivalent of the
     number \a n to base \a base, which is 10 by default and must be
     between 2 and 36.
 
     \code
 	long a = 63;
 	QString str = QString::number( a, 16 );             // str == "3f"
 	QString str = QString::number( a, 16 ).upper();     // str == "3F"
     \endcode
 
     \sa setNum()
 */
 QString QString::number( long n, int base )
 {
     QString s;
     s.setNum( n, base );
     return s;
 }
 
 /*!
     \overload
 
     \sa setNum()
 */
 QString QString::number( ulong n, int base )
 {
     QString s;
     s.setNum( n, base );
     return s;
 }
 
 /*!
     \overload
 
     \sa setNum()
 */
 QString QString::number( int n, int base )
 {
     QString s;
     s.setNum( n, base );
     return s;
 }
 
 /*!
     \overload
 
     A convenience factory function that returns a string
     representation of the number \a n to the base \a base, which is 10
     by default and must be between 2 and 36.
 
     \sa setNum()
 */
 QString QString::number( uint n, int base )
 {
     QString s;
     s.setNum( n, base );
     return s;
 }
 
 /*!
     \overload
 
     Argument \a n is formatted according to the \a f format specified,
     which is \c g by default, and can be any of the following:
 
     \table
     \header \i Format \i Meaning
     \row \i \c e \i format as [-]9.9e[+|-]999
     \row \i \c E \i format as [-]9.9E[+|-]999
     \row \i \c f \i format as [-]9.9
     \row \i \c g \i use \c e or \c f format, whichever is the most concise
     \row \i \c G \i use \c E or \c f format, whichever is the most concise
     \endtable
 
     With 'e', 'E', and 'f', \a prec is the number of digits after the
     decimal point. With 'g' and 'G', \a prec is the maximum number of
     significant digits (trailing zeroes are omitted).
 
     \code
     double d = 12.34;
     QString ds = QString( "'E' format, precision 3, gives %1" )
 		    .arg( d, 0, 'E', 3 );
     // ds == "1.234E+001"
     \endcode
 
     \sa setNum()
     */
 QString QString::number( double n, char f, int prec )
 {
     QString s;
     s.setNum( n, f, prec );
     return s;
 }
 
 
 /*! \obsolete
 
   Sets the character at position \a index to \a c and expands the
   string if necessary, filling with spaces.
 
   This method is redundant in Qt 3.x, because operator[] will expand
   the string as necessary.
 */
 
 void QString::setExpand( uint index, QChar c )
 {
     int spaces = index - d->len;
     at(index) = c;
     while (spaces-->0)
 	d->unicode[--index]=' ';
 }
 
 
 /*!
   \fn const char* QString::data() const
 
   \obsolete
 
   Returns a pointer to a '\0'-terminated classic C string.
 
   In Qt 1.x, this returned a char* allowing direct manipulation of the
   string as a sequence of bytes. In Qt 2.x where QString is a Unicode
   string, char* conversion constructs a temporary string, and hence
   direct character operations are meaningless.
 */
 
 /*!
     \fn bool QString::operator!() const
 
     Returns TRUE if this is a null string; otherwise returns FALSE.
 
     \code
 	QString name = getName();
 	if ( !name )
 	    name = "Rodney";
     \endcode
 
     Note that if you say
 
     \code
 	QString name = getName();
 	if ( name )
 	    doSomethingWith(name);
     \endcode
 
     It will call "operator const char*()", which is inefficent; you
     may wish to define the macro \c QT_NO_ASCII_CAST when writing code
     which you wish to remain Unicode-clean.
 
     When you want the above semantics, use:
 
     \code
 	QString name = getName();
 	if ( !name.isNull() )
 	    doSomethingWith(name);
     \endcode
 
     \sa isEmpty()
 */
 
 
 /*!
     \fn QString& QString::append( const QString& str )
 
     Appends \a str to the string and returns a reference to the
     result.
 
     \code
 	string = "Test";
 	string.append( "ing" );        // string == "Testing"
     \endcode
 
     Equivalent to operator+=().
 */
 
 /*!
     \fn QString& QString::append( char ch )
 
     \overload
 
     Appends character \a ch to the string and returns a reference to
     the result.
 
     Equivalent to operator+=().
 */
 
 /*!
     \fn QString& QString::append( QChar ch )
 
     \overload
 
     Appends character \a ch to the string and returns a reference to
     the result.
 
     Equivalent to operator+=().
 */
 
 /*! \fn QString& QString::append( const QByteArray &str )
   \overload
 
   Appends \a str to the string and returns a reference to the result.
 
   Equivalent to operator+=().
  */
 
+/*! \fn QString& QString::append( const std::string &str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the result.
+
+  Equivalent to operator+=().
+ */
+
+
 /*! \fn QString& QString::append( const char *str )
   \overload
 
   Appends \a str to the string and returns a reference to the result.
 
   Equivalent to operator+=().
  */
 
 /*!
     Appends \a str to the string and returns a reference to the string.
 */
 QString& QString::operator+=( const QString &str )
 {
     uint len1 = length();
     uint len2 = str.length();
     if ( len2 ) {
 	setLength(len1+len2);
 	memcpy( d->unicode+len1, str.unicode(), sizeof(QChar)*len2 );
     } else if ( isNull() && !str.isNull() ) {   // ## just for 1.x compat:
 	*this = fromLatin1( "" );
     }
     return *this;
 }
 
 /*!
     \overload
 
   Appends \a str to the string and returns a reference to the string.
 */
+#ifndef QT_NO_CAST_ASCII
 QString& QString::operator+=( const char *str )
 {
     if ( str ) {
+#ifndef QT_NO_TEXTCODEC
+	if ( QTextCodec::codecForCStrings() )
+	    return operator+=( fromAscii( str ) );
+#endif
+
 	uint len1 = length();
 	uint len2 = strlen( str );
 	if ( len2 ) {
 	    setLength(len1+len2);
 	    uint i = 0;
 	    while( i < len2 ) {
 		d->unicode[len1+i] = str[i];
 		i++;
 	    }
 	} else if ( isNull() ) {   // ## just for 1.x compat:
 	    *this = fromLatin1( "" );
 	}
     }
     return *this;
 }
+#endif
 
 /*! \overload
 
   Appends \a c to the string and returns a reference to the string.
 */
 
 QString &QString::operator+=( QChar c )
 {
     setLength(length()+1);
     d->unicode[length()-1] = c;
     return *this;
 }
 
 /*!
     \overload
 
     Appends \a c to the string and returns a reference to the string.
 */
 
 QString &QString::operator+=( char c )
 {
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() )
+	return operator+=( fromAscii( &c, 1 ) );
+#endif
     setLength(length()+1);
     d->unicode[length()-1] = c;
     return *this;
 }
 
 /*!
   \fn QString &QString::operator+=( const QByteArray &str )
   \overload
 
   Appends \a str to the string and returns a reference to the string.
 */
 
+/*!
+  \fn QString &QString::operator+=( const std::string &str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the string.
+*/
+
 
 
 /*!
     \fn char QChar::latin1() const
 
-    Returns a latin-1 copy of this character, if this character is in
-    the latin-1 character set. If not, this function returns 0.
+    Returns the Latin-1 value of this character, or 0 if it
+    cannot be represented in Latin-1.
 */
 
 
 /*!
-    Returns a Latin-1 representation of the string. Note that the
+    Returns a Latin-1 representation of the string. The
     returned value is undefined if the string contains non-Latin-1
     characters. If you want to convert strings into formats other than
     Unicode, see the QTextCodec classes.
 
     This function is mainly useful for boot-strapping legacy code to
     use Unicode.
 
     The result remains valid so long as one unmodified copy of the
     source string exists.
 
-    \sa utf8(), local8Bit()
+    \sa fromLatin1(), ascii(), utf8(), local8Bit()
 */
 const char* QString::latin1() const
 {
-    if ( !d->ascii ) {
-	Q2HELPER(stat_get_ascii++)
-	Q2HELPER(stat_get_ascii_size+=d->len)
-	d->ascii = unicodeToAscii( d->unicode, d->len );
+    if ( !d->ascii  || !d->islatin1 ) {
+	d->ascii = unicodeToLatin1( d->unicode, d->len );
+	d->islatin1 = TRUE;
     }
     return d->ascii;
 }
 
 /*!
-  \fn const char* QString::ascii() const
-  \obsolete
+    Returns an 8-bit ASCII representation of the string.
 
-  This function simply calls latin1() and returns the result.
+    If a codec has been set using QTextCodec::codecForCStrings(),
+    it is used to convert Unicode to 8-bit char. Otherwise, this function
+    does the same as latin1().
+
+    \sa fromAscii(), latin1(), utf8(), local8Bit()
 */
+const char* QString::ascii() const
+{
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+	if ( !d->ascii || d->islatin1 ) {
+	    QCString s = QTextCodec::codecForCStrings()->fromUnicode( *this );
+	    s.detach();
+	    d->ascii = s.data();
+	    d->islatin1 = FALSE;
+	    s.resetRawData( s.data(), s.size() ); // we have stolen the data
+	}
+	return d->ascii;
+    }
+#endif // QT_NO_TEXTCODEC
+    return latin1();
+}
 
 /*!
-    Returns the string encoded in UTF8 format.
+    Returns the string encoded in UTF-8 format.
 
     See QTextCodec for more diverse coding/decoding of Unicode strings.
 
-    \sa QString::fromUtf8(), local8Bit(), latin1()
+    \sa fromUtf8(), ascii(), latin1(), local8Bit()
 */
 QCString QString::utf8() const
 {
     int l = length();
     int rlen = l*3+1;
     QCString rstr(rlen);
     uchar* cursor = (uchar*)rstr.data();
     const QChar *ch = d->unicode;
     for (int i=0; i<l; i++) {
 	ushort u = ch->unicode();
  	if ( u < 0x80 ) {
  	    *cursor++ = (uchar)u;
  	} else {
  	    if ( u < 0x0800 ) {
 		*cursor++ = 0xc0 | ((uchar) (u >> 6));
  	    } else {
  		*cursor++ = 0xe0 | ((uchar) (u >> 12));
  		*cursor++ = 0x80 | ( ((uchar) (u >> 6)) & 0x3f);
  	    }
  	    *cursor++ = 0x80 | ((uchar) (u&0x3f));
  	}
  	ch++;
     }
     rstr.truncate( cursor - (uchar*)rstr.data() );
     return rstr;
 }
 
 /*!
     Returns the Unicode string decoded from the first \a len
     characters of \a utf8, ignoring the rest of \a utf8. If \a len is
     -1 then the length of \a utf8 is used. If \a len is bigger than
     the length of \a utf8 then it will use the length of \a utf8.
 
     \code
 	QString str = QString::fromUtf8( "123456789", 5 );
 	// str == "12345"
     \endcode
 
     See QTextCodec for more diverse coding/decoding of Unicode strings.
 */
 QString QString::fromUtf8( const char* utf8, int len )
 {
     if ( !utf8 )
 	return QString::null;
 
-    if ( len < 0 ) len = qstrlen( utf8 );
+    if ( len < 0 )
+	len = strlen( utf8 );
     QString result;
     result.setLength( len ); // worst case
     QChar *qch = (QChar *)result.unicode();
     ushort uc = 0;
     int need = 0;
     for (int i=0; i<len; i++) {
 	uchar ch = utf8[i];
 	if (need) {
 	    if ( (ch&0xc0) == 0x80 ) {
 		uc = (uc << 6) | (ch & 0x3f);
 		need--;
 		if ( !need ) {
 		    *qch = uc;
 		    qch++;
 		}
 	    } else {
 		// error
 		*qch = QChar::replacement;
 		qch++;
 		need = 0;
 	    }
 	} else {
 	    if ( ch < 128 ) {
 		*qch = ch;
 		qch++;
 	    } else if ( (ch&0xe0) == 0xc0 ) {
 		uc = ch &0x1f;
 		need = 1;
 	    } else if ( (ch&0xf0) == 0xe0 ) {
 		uc = ch &0x0f;
 		need = 2;
 	    }
 	}
     }
     result.truncate( qch - result.unicode() );
     return result;
 }
 
 /*!
     Returns the Unicode string decoded from the first \a len
-    characters of \a chars, ignoring the rest of \a chars. If \a len
-    is -1 then the length of \a chars is used. If \a len is bigger
-    than the length of \a chars then it will use the length of \a
-    chars.
+    characters of \a ascii, ignoring the rest of \a ascii. If \a len
+    is -1 then the length of \a ascii is used. If \a len is bigger
+    than the length of \a ascii then it will use the length of \a
+    ascii.
+
+    If a codec has been set using QTextCodec::codecForCStrings(),
+    it is used to convert Unicode to 8-bit char. Otherwise, this function
+    does the same as fromLatin1().
 
     This is the same as the QString(const char*) constructor, but you
     can make that constructor invisible if you compile with the define
     \c QT_NO_CAST_ASCII, in which case you can explicitly create a
-    QString from Latin-1 text using this function.
+    QString from 8-bit ASCII text using this function.
 
     \code
-	QString str = QString::fromLatin1( "123456789", 5 );
+	QString str = QString::fromAscii( "123456789", 5 );
 	// str == "12345"
     \endcode
+ */
+QString QString::fromAscii( const char* ascii, int len )
+{
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+	if ( !ascii )
+	    return QString::null;
+	if ( len < 0 )
+	    len = strlen( ascii );
+	if ( len == 0 || *ascii == '\0' )
+	    return QString::fromLatin1( "" );
+	return QTextCodec::codecForCStrings()->toUnicode( ascii, len );
+    }
+#endif
+    return fromLatin1( ascii, len );
+}
+
+
+/*!
+    Returns the Unicode string decoded from the first \a len
+    characters of \a chars, ignoring the rest of \a chars. If \a len
+    is -1 then the length of \a chars is used. If \a len is bigger
+    than the length of \a chars then it will use the length of \a
+    chars.
+
+    \sa fromAscii()
 */
 QString QString::fromLatin1( const char* chars, int len )
 {
     uint l;
     QChar *uc;
     if ( len < 0 )
 	 len = -1;
-    uc = internalAsciiToUnicode( chars, &l, len );
+    uc = internalLatin1ToUnicode( chars, &l, len );
     return QString( new QStringData(uc, l, l), TRUE );
 }
 
 /*!
     \fn const QChar* QString::unicode() const
 
     Returns the Unicode representation of the string. The result
     remains valid until the string is modified.
 */
 
 /*!
     Returns the string encoded in a locale-specific format. On X11,
     this is the QTextCodec::codecForLocale(). On Windows, it is a
-    system-defined encoding. On Mac OS X, this always uses utf8 as the
-    encoding.
+    system-defined encoding. On Mac OS X, this always uses UTF-8 as
+    the encoding.
 
     See QTextCodec for more diverse coding/decoding of Unicode
     strings.
 
-    \sa QString::fromLocal8Bit(), latin1(), utf8()
+    \sa fromLocal8Bit(), ascii(), latin1(), utf8()
 */
 
-
 QCString QString::local8Bit() const
 {
 #ifdef QT_NO_TEXTCODEC
     return latin1();
 #else
 #ifdef Q_WS_X11
     QTextCodec* codec = QTextCodec::codecForLocale();
     return codec
 	    ? codec->fromUnicode(*this)
 	    : QCString(latin1());
 #endif
 #if defined( Q_WS_MACX )
     return utf8();
 #endif
 #if defined( Q_WS_MAC9 )
     return QCString(latin1()); //I'm evil..
 #endif
 #ifdef Q_WS_WIN
     return qt_winQString2MB( *this );
 #endif
 #ifdef Q_WS_QWS
-    return utf8(); // ##### if there is ANY 8 bit format supported?
+    return utf8(); // ### if there is any 8 bit format supported?
 #endif
 #endif
 }
 
 /*!
     Returns the Unicode string decoded from the first \a len
     characters of \a local8Bit, ignoring the rest of \a local8Bit. If
     \a len is -1 then the length of \a local8Bit is used. If \a len is
     bigger than the length of \a local8Bit then it will use the length
     of \a local8Bit.
 
     \code
 	QString str = QString::fromLocal8Bit( "123456789", 5 );
 	// str == "12345"
     \endcode
 
     \a local8Bit is assumed to be encoded in a locale-specific format.
 
     See QTextCodec for more diverse coding/decoding of Unicode strings.
 */
 QString QString::fromLocal8Bit( const char* local8Bit, int len )
 {
 #ifdef QT_NO_TEXTCODEC
     return fromLatin1( local8Bit, len );
 #else
 
     if ( !local8Bit )
 	return QString::null;
 #ifdef Q_WS_X11
     QTextCodec* codec = QTextCodec::codecForLocale();
-    if ( len < 0 ) len = qstrlen(local8Bit);
+    if ( len < 0 )
+	len = strlen( local8Bit );
     return codec
 	    ? codec->toUnicode( local8Bit, len )
 	    : fromLatin1( local8Bit, len );
 #endif
 #if defined( Q_WS_MAC )
     return fromUtf8(local8Bit,len);
 #endif
 // Should this be OS_WIN32?
 #ifdef Q_WS_WIN
     if ( len >= 0 ) {
 	QCString s(local8Bit,len+1);
 	return qt_winMB2QString(s);
     }
     return qt_winMB2QString( local8Bit );
 #endif
 #ifdef Q_WS_QWS
     return fromUtf8(local8Bit,len);
 #endif
 #endif // QT_NO_TEXTCODEC
 }
 
 /*!
     \fn QString::operator const char *() const
 
     Returns latin1(). Be sure to see the warnings documented in the
     latin1() function. Note that for new code which you wish to be
     strictly Unicode-clean, you can define the macro \c
     QT_NO_ASCII_CAST when compiling your code to hide this function so
     that automatic casts are not done. This has the added advantage
     that you catch the programming error described in operator!().
 */
 
+/*!
+    \fn QString::operator std::string() const
+
+    Returns ascii().
+*/
+
 
 /*!
     Returns the QString as a zero terminated array of unsigned shorts
     if the string is not null; otherwise returns zero.
 
     The result remains valid so long as one unmodified
     copy of the source string exists.
 */
 const unsigned short *QString::ucs2() const
 {
     if ( ! d->unicode )
 	return 0;
     unsigned int len = d->len;
     if ( d->maxl < len + 1 ) {
 	// detach, grow or shrink
-	Q2HELPER(stat_copy_on_write++)
-	Q2HELPER(stat_copy_on_write_size += len)
 	uint newMax = computeNewMax( len + 1 );
 	QChar* nd = QT_ALLOC_QCHAR_VEC( newMax );
 	if ( nd ) {
 	    if ( d->unicode )
 		memcpy( nd, d->unicode, sizeof(QChar)*len );
 	    ((QString *)this)->deref();
 	    ((QString *)this)->d = new QStringData( nd, len, newMax );
 	}
     }
     d->unicode[len] = 0;
     return (unsigned short *) d->unicode;
 }
 
 /*!
   Constructs a string that is a deep copy of \a str, interpreted as a
   UCS2 encoded, zero terminated, Unicode string.
 
   If \a str is 0, then a null string is created.
 
   \sa isNull()
 */
 QString QString::fromUcs2( const unsigned short *str )
 {
     if ( !str ) {
 	return QString::null;
     } else {
 	int length = 0;
 	while( str[length] != 0 )
 	    length++;
 	QChar* uc = QT_ALLOC_QCHAR_VEC( length );
 	memcpy( uc, str, length*sizeof(QChar) );
 	return QString( new QStringData( uc, length, length ), TRUE );
     }
 }
 
 /*!
   \fn QChar QString::at( uint ) const
 
     Returns the character at index \a i, or 0 if \a i is beyond the
     length of the string.
 
     \code
 	const QString string( "abcdefgh" );
 	QChar ch = string.at( 4 );
 	// ch == 'e'
     \endcode
 
     If the QString is not const (i.e. const QString) or const& (i.e.
     const QString &), then the non-const overload of at() will be used
     instead.
 */
 
 /*!
     \fn QChar QString::constref(uint i) const
 
     Returns the QChar at index \a i by value.
 
     Equivalent to at(\a i).
 
     \sa ref()
 */
 
 /*!
     \fn QChar& QString::ref(uint i)
 
     Returns the QChar at index \a i by reference, expanding the string
     with QChar::null if necessary. The resulting reference can be
     assigned to, or otherwise used immediately, but becomes invalid
     once furher modifications are made to the string.
 
     \code
 	QString string("ABCDEF");
 	QChar ch = string.ref( 3 );         // ch == 'D'
     \endcode
 
     \sa constref()
 */
 
 /*!
     \fn QChar QString::operator[]( int ) const
 
     Returns the character at index \a i, or QChar::null if \a i is
     beyond the length of the string.
 
     If the QString is not const (i.e., const QString) or const\&
     (i.e., const QString\&), then the non-const overload of operator[]
     will be used instead.
 */
 
 /*!
     \fn QCharRef QString::operator[]( int )
 
     \overload
 
     The function returns a reference to the character at index \a i.
     The resulting reference can then be assigned to, or used
     immediately, but it will become invalid once further modifications
     are made to the original string.
 
     If \a i is beyond the length of the string then the string is
     expanded with QChar::nulls, so that the QCharRef references a
     valid (null) character in the string.
 
     The QCharRef internal class can be used much like a constant
     QChar, but if you assign to it, you change the original string
     (which will detach itself because of QString's copy-on-write
     semantics). You will get compilation errors if you try to use the
     result as anything but a QChar.
 */
 
 /*!
     \fn QCharRef QString::at( uint i )
 
     \overload
 
     The function returns a reference to the character at index \a i.
     The resulting reference can then be assigned to, or used
     immediately, but it will become invalid once further modifications
     are made to the original string.
 
     If \a i is beyond the length of the string then the string is
     expanded with QChar::null.
 */
 
 /*
   Internal chunk of code to handle the
   uncommon cases of at() above.
 */
 void QString::subat( uint i )
 {
     uint olen = d->len;
     if ( i >= olen ) {
 	setLength( i+1 );               // i is index; i+1 is needed length
 	for ( uint j=olen; j<=i; j++ )
 	    d->unicode[j] = QChar::null;
     } else {
 	// Just be sure to detach
 	real_detach();
     }
 }
 
 
 /*!
     Resizes the string to \a len characters and copies \a unicode into
     the string. If \a unicode is 0, nothing is copied, but the
     string is still resized to \a len. If \a len is zero, then the
     string becomes a \link isNull() null\endlink string.
 
     \sa setLatin1(), isNull()
 */
 
 QString& QString::setUnicode( const QChar *unicode, uint len )
 {
     if ( len == 0 ) {                           // set to null string
 	if ( d != shared_null ) {               // beware of nullstring being set to nullstring
 	    deref();
 	    d = shared_null ? shared_null : makeSharedNull();
 	    d->ref();
 	}
     } else if ( d->count != 1 || len > d->maxl ||
 		( len * 4 < d->maxl && d->maxl > 4 ) ) {
 	// detach, grown or shrink
-	Q2HELPER(stat_copy_on_write++)
-	Q2HELPER(stat_copy_on_write_size+=d->len)
 	uint newMax = computeNewMax( len );
 	QChar* nd = QT_ALLOC_QCHAR_VEC( newMax );
 	if ( unicode )
 	    memcpy( nd, unicode, sizeof(QChar)*len );
 	deref();
 	d = new QStringData( nd, len, newMax );
     } else {
 	d->len = len;
 	d->setDirty();
 	if ( unicode )
 	    memcpy( d->unicode, unicode, sizeof(QChar)*len );
     }
     return *this;
 }
 
 /*!
     Resizes the string to \a len characters and copies \a
     unicode_as_ushorts into the string (on some X11 client platforms
     this will involve a byte-swapping pass).
 
     If \a unicode_as_ushorts is 0, nothing is copied, but the string
     is still resized to \a len. If \a len is zero, the string becomes
     a \link isNull() null\endlink string.
 
     \sa setLatin1(), isNull()
 */
 QString& QString::setUnicodeCodes( const ushort* unicode_as_ushorts, uint len )
 {
      return setUnicode((const QChar*)unicode_as_ushorts, len);
 }
 
 
 /*!
+    Sets this string to \a str, interpreted as a classic 8-bit ASCII C
+    string. If \a len is -1 (the default), then it is set to
+    strlen(str).
+
+    If \a str is 0 a null string is created. If \a str is "", an empty
+    string is created.
+
+    \sa isNull(), isEmpty()
+*/
+
+QString &QString::setAscii( const char *str, int len )
+{
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+	*this = QString::fromAscii( str, len );
+	return *this;
+    }
+#endif // QT_NO_TEXTCODEC
+    return setLatin1( str, len );
+}
+
+/*!
     Sets this string to \a str, interpreted as a classic Latin1 C
     string. If \a len is -1 (the default), then it is set to
     strlen(str).
 
     If \a str is 0 a null string is created. If \a str is "", an empty
     string is created.
 
     \sa isNull(), isEmpty()
 */
 
 QString &QString::setLatin1( const char *str, int len )
 {
     if ( str == 0 )
 	return setUnicode(0,0);
     if ( len < 0 )
-	len = qstrlen(str);
+	len = strlen( str );
     if ( len == 0 ) {                           // won't make a null string
 	*this = QString::fromLatin1( "" );
     } else {
 	setUnicode( 0, len );                   // resize but not copy
 	QChar *p = d->unicode;
 	while ( len-- )
 	    *p++ = *str++;
     }
     return *this;
 }
 
 /*! \internal
  */
 void QString::checkSimpleText() const
 {
     QChar *p = d->unicode;
     QChar *end = p + d->len;
-    d->simpletext = 1;
     while( p < end ) {
 	ushort uc = p->unicode();
 	// sort out regions of complex text formatting
 	if ( uc > 0x058f && ( uc < 0x1100 || uc > 0xfb0f ) ) {
-	    d->simpletext = 0;
+	    d->issimpletext = FALSE;
 	    return;
 	}
 	p++;
     }
+    d->issimpletext = TRUE;
 }
 
 /*! \fn bool QString::simpleText() const
   \internal
 */
 
 /*! \internal
  */
 bool QString::isRightToLeft() const
 {
     int len = length();
     QChar *p = d->unicode;
     while( len-- ) {
 	switch( ::direction( *p ) )
 	{
 	case QChar::DirL:
 	case QChar::DirLRO:
 	case QChar::DirLRE:
 	    return FALSE;
 	case QChar::DirR:
 	case QChar::DirAL:
 	case QChar::DirRLO:
 	case QChar::DirRLE:
 	    return TRUE;
 	default:
 	    break;
 	}
 	++p;
     }
     return FALSE;
 }
 
 
 /*!
     \fn int QString::compare( const QString & s1, const QString & s2 )
 
     Lexically compares \a s1 with \a s2 and returns an integer less
     than, equal to, or greater than zero if \a s1 is less than, equal
     to, or greater than \a s2.
 
     The comparison is based exclusively on the numeric Unicode values
     of the characters and is very fast, but is not what a human would
     expect. Consider sorting user-interface strings with
     QString::localeAwareCompare().
 
     \code
 	int a = QString::compare( "def", "abc" );   // a > 0
 	int b = QString::compare( "abc", "def" );   // b < 0
 	int c = QString::compare(" abc", "abc" );   // c == 0
     \endcode
 */
 
 /*!
     \overload
 
    Lexically compares this string with \a s and returns an integer
    less than, equal to, or greater than zero if it is less than, equal
    to, or greater than \a s.
 */
 int QString::compare( const QString& s ) const
 {
     return ucstrcmp( *this, s );
 }
 
 /*!
     \fn int QString::localeAwareCompare( const QString & s1, const QString & s2 )
 
     Compares \a s1 with \a s2 and returns an integer less than, equal
     to, or greater than zero if \a s1 is less than, equal to, or
     greater than \a s2.
 
     The comparison is performed in a locale- and also
     platform-dependent manner. Use this function to present sorted
     lists of strings to the user.
 
     \sa QString::compare() QTextCodec::locale()
 */
 
 /*!
     \overload
 
     Compares this string with \a s.
 */
 
 #if !defined(CSTR_LESS_THAN)
 #define CSTR_LESS_THAN    1
 #define CSTR_EQUAL        2
 #define CSTR_GREATER_THAN 3
 #endif
 
 int QString::localeAwareCompare( const QString& s ) const
 {
     // do the right thing for null and empty
     if ( isEmpty() || s.isEmpty() )
 	return compare( s );
 
 #if defined(Q_WS_WIN)
     int res;
     QT_WA( {
 	const TCHAR* s1 = (TCHAR*)ucs2();
 	const TCHAR* s2 = (TCHAR*)s.ucs2();
 	res = CompareStringW( LOCALE_USER_DEFAULT, 0, s1, length(), s2, s.length() );
     } , {
 	QCString s1 = local8Bit();
 	QCString s2 = s.local8Bit();
 	res = CompareStringA( LOCALE_USER_DEFAULT, 0, s1.data(), s1.length(), s2.data(), s2.length() );
     } );
 
     switch ( res ) {
     case CSTR_LESS_THAN:
 	return -1;
     case CSTR_GREATER_THAN:
 	return 1;
     default:
 	return 0;
     }
 #elif defined(Q_WS_X11)
     // declared in <string.h>
     int delta = strcoll( local8Bit(), s.local8Bit() );
     if ( delta == 0 )
 	delta = ucstrcmp( *this, s );
     return delta;
 #else
     return ucstrcmp( *this, s );
 #endif
 }
 
 bool operator==( const QString &s1, const QString &s2 )
 {
     if ( s1.unicode() == s2.unicode() )
 	return TRUE;
     return (s1.length() == s2.length()) && s1.isNull() == s2.isNull() &&
 	 (memcmp((char*)s1.unicode(),(char*)s2.unicode(),
 		 s1.length()*sizeof(QChar)) == 0 );
 }
 
 bool operator!=( const QString &s1, const QString &s2 )
 { return !(s1==s2); }
 
 bool operator<( const QString &s1, const QString &s2 )
 { return ucstrcmp(s1,s2) < 0; }
 
 bool operator<=( const QString &s1, const QString &s2 )
 { return ucstrcmp(s1,s2) <= 0; }
 
 bool operator>( const QString &s1, const QString &s2 )
 { return ucstrcmp(s1,s2) > 0; }
 
 bool operator>=( const QString &s1, const QString &s2 )
 { return ucstrcmp(s1,s2) >= 0; }
 
 
 bool operator==( const QString &s1, const char *s2 )
 {
     if ( !s2 )
 	return s1.isNull();
 
     int len = s1.length();
     const QChar *uc = s1.unicode();
     while ( len ) {
 	if ( !(*s2) || uc->unicode() != (uchar) *s2 )
 	    return FALSE;
 	++uc;
 	++s2;
 	--len;
     }
     return !*s2;
 }
 
 bool operator==( const char *s1, const QString &s2 )
 { return (s2 == s1); }
 
 bool operator!=( const QString &s1, const char *s2 )
 { return !(s1==s2); }
 
 bool operator!=( const char *s1, const QString &s2 )
 { return !(s1==s2); }
 
 bool operator<( const QString &s1, const char *s2 )
 { return ucstrcmp(s1,s2) < 0; }
 
 bool operator<( const char *s1, const QString &s2 )
 { return ucstrcmp(s1,s2) < 0; }
 
 bool operator<=( const QString &s1, const char *s2 )
 { return ucstrcmp(s1,s2) <= 0; }
 
 bool operator<=( const char *s1, const QString &s2 )
 { return ucstrcmp(s1,s2) <= 0; }
 
 bool operator>( const QString &s1, const char *s2 )
 { return ucstrcmp(s1,s2) > 0; }
 
 bool operator>( const char *s1, const QString &s2 )
 { return ucstrcmp(s1,s2) > 0; }
 
 bool operator>=( const QString &s1, const char *s2 )
 { return ucstrcmp(s1,s2) >= 0; }
 
 bool operator>=( const char *s1, const QString &s2 )
 { return ucstrcmp(s1,s2) >= 0; }
 
 
 /*****************************************************************************
   Documentation for QString related functions
  *****************************************************************************/
 
 /*!
     \fn bool operator==( const QString &s1, const QString &s2 )
 
     \relates QString
 
     Returns TRUE if \a s1 is equal to \a s2; otherwise returns FALSE.
     Note that a null string is not equal to a not-null empty string.
 
     Equivalent to compare(\a s1, \a s2) != 0.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     \fn bool operator==( const QString &s1, const char *s2 )
 
     \overload
     \relates QString
 
     Returns TRUE if \a s1 is equal to \a s2; otherwise returns FALSE.
     Note that a null string is not equal to a not-null empty string.
 
     Equivalent to compare(\a s1, \a s2) == 0.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     \fn bool operator==( const char *s1, const QString &s2 )
 
     \overload
     \relates QString
 
     Returns TRUE if \a s1 is equal to \a s2; otherwise returns FALSE.
     Note that a null string is not equal to a not-null empty string.
 
     Equivalent to compare(\a s1, \a s2) == 0.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     \fn bool operator!=( const QString &s1, const QString &s2 )
 
     \relates QString
 
     Returns TRUE if \a s1 is not equal to \a s2; otherwise returns FALSE.
     Note that a null string is not equal to a not-null empty string.
 
     Equivalent to compare(\a s1, \a s2) != 0.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     \fn bool operator!=( const QString &s1, const char *s2 )
 
     \overload
     \relates QString
 
     Returns TRUE if \a s1 is not equal to \a s2; otherwise returns FALSE.
     Note that a null string is not equal to a not-null empty string.
 
     Equivalent to compare(\a s1, \a s2) != 0.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     \fn bool operator!=( const char *s1, const QString &s2 )
 
     \overload
     \relates QString
 
     Returns TRUE if \a s1 is not equal to \a s2; otherwise returns FALSE.
     Note that a null string is not equal to a not-null empty string.
 
     Equivalent to compare(\a s1, \a s2) != 0.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     \fn bool operator<( const QString &s1, const char *s2 )
 
     \relates QString
 
     Returns TRUE if \a s1 is lexically less than \a s2; otherwise returns FALSE.
     The comparison is case sensitive.
 
     Equivalent to compare(\a s1, \a s2) \< 0.
 */
 
 /*!
     \fn bool operator<( const char *s1, const QString &s2 )
 
     \overload
     \relates QString
 
     Returns TRUE if \a s1 is lexically less than \a s2; otherwise returns FALSE.
     The comparison is case sensitive.
 
     Equivalent to compare(\a s1, \a s2) \< 0.
 */
 
 /*!
     \fn bool operator<=( const QString &s1, const char *s2 )
 
     \relates QString
 
     Returns TRUE if \a s1 is lexically less than or equal to \a s2;
     otherwise returns FALSE.
     The comparison is case sensitive.
     Note that a null string is not equal to a not-null empty string.
 
     Equivalent to compare(\a s1,\a s2) \<= 0.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     \fn bool operator<=( const char *s1, const QString &s2 )
 
     \overload
     \relates QString
 
     Returns TRUE if \a s1 is lexically less than or equal to \a s2;
     otherwise returns FALSE.
     The comparison is case sensitive.
     Note that a null string is not equal to a not-null empty string.
 
     Equivalent to compare(\a s1, \a s2) \<= 0.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     \fn bool operator>( const QString &s1, const char *s2 )
 
     \relates QString
 
     Returns TRUE if \a s1 is lexically greater than \a s2; otherwise
     returns FALSE.
     The comparison is case sensitive.
 
     Equivalent to compare(\a s1, \a s2) \> 0.
 */
 
 /*!
     \fn bool operator>( const char *s1, const QString &s2 )
 
     \overload
     \relates QString
 
     Returns TRUE if \a s1 is lexically greater than \a s2; otherwise
     returns FALSE.
     The comparison is case sensitive.
 
     Equivalent to compare(\a s1, \a s2) \> 0.
 */
 
 /*!
     \fn bool operator>=( const QString &s1, const char *s2 )
 
     \relates QString
 
     Returns TRUE if \a s1 is lexically greater than or equal to \a s2;
     otherwise returns FALSE.
     The comparison is case sensitive.
     Note that a null string is not equal to a not-null empty string.
 
     Equivalent to compare(\a s1, \a s2) \>= 0.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     \fn bool operator>=( const char *s1, const QString &s2 )
 
     \overload
     \relates QString
 
     Returns TRUE if \a s1 is lexically greater than or equal to \a s2;
     otherwise returns FALSE.
     The comparison is case sensitive.
     Note that a null string is not equal to a not-null empty string.
 
     Equivalent to compare(\a s1, \a s2) \>= 0.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     \fn const QString operator+( const QString &s1, const QString &s2 )
 
     \relates QString
 
     Returns a string which is the result of concatenating the string
     \a s1 and the string \a s2.
 
     Equivalent to \a {s1}.append(\a s2).
 */
 
 /*!
     \fn const QString operator+( const QString &s1, const char *s2 )
 
     \overload
     \relates QString
 
     Returns a string which is the result of concatenating the string
     \a s1 and character \a s2.
 
     Equivalent to \a {s1}.append(\a s2).
 */
 
 /*!
     \fn const QString operator+( const char *s1, const QString &s2 )
 
     \overload
     \relates QString
 
     Returns a string which is the result of concatenating the
     character \a s1 and string \a s2.
 */
 
 /*!
     \fn const QString operator+( const QString &s, char c )
 
     \overload
     \relates QString
 
     Returns a string which is the result of concatenating the string
     \a s and character \a c.
 
     Equivalent to \a {s}.append(\a c).
 */
 
 /*!
     \fn const QString operator+( char c, const QString &s )
 
     \overload
     \relates QString
 
     Returns a string which is the result of concatenating the
     character \a c and string \a s.
 
     Equivalent to \a {s}.prepend(\a c).
 */
 
 
 /*****************************************************************************
   QString stream functions
  *****************************************************************************/
 #ifndef QT_NO_DATASTREAM
 /*!
     \relates QString
 
     Writes the string \a str to the stream \a s.
 
     See also \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator<<( QDataStream &s, const QString &str )
 {
     if ( s.version() == 1 ) {
 	QCString l( str.latin1() );
 	s << l;
     }
     else {
 	int byteOrder = s.byteOrder();
 	const QChar* ub = str.unicode();
 	if ( ub || s.version() < 3 ) {
 	    static const uint auto_size = 1024;
 	    char t[auto_size];
 	    char *b;
 	    if ( str.length()*sizeof(QChar) > auto_size ) {
 		b = new char[str.length()*sizeof(QChar)];
 	    } else {
 		b = t;
 	    }
 	    int l = str.length();
 	    char *c=b;
 	    while ( l-- ) {
 		if ( byteOrder == QDataStream::BigEndian ) {
 		    *c++ = (char)ub->row();
 		    *c++ = (char)ub->cell();
 		} else {
 		    *c++ = (char)ub->cell();
 		    *c++ = (char)ub->row();
 		}
 		ub++;
 	    }
 	    s.writeBytes( b, sizeof(QChar)*str.length() );
 	    if ( str.length()*sizeof(QChar) > auto_size )
 		delete [] b;
 	} else {
 	    // write null marker
 	    s << (Q_UINT32)0xffffffff;
 	}
     }
     return s;
 }
 
 /*!
     \relates QString
 
     Reads a string from the stream \a s into string \a str.
 
     See also \link datastreamformat.html Format of the QDataStream operators \endlink
 */
 
 QDataStream &operator>>( QDataStream &s, QString &str )
 {
 #ifdef QT_QSTRING_UCS_4
 #if defined(Q_CC_GNU)
 #warning "operator>> not working properly"
 #endif
 #endif
     if ( s.version() == 1 ) {
 	QCString l;
 	s >> l;
 	str = QString( l );
     }
     else {
 	Q_UINT32 bytes;
 	s >> bytes;                                     // read size of string
 	if ( bytes == 0xffffffff ) {                    // null string
 	    str = QString::null;
 	} else if ( bytes > 0 ) {                       // not empty
 	    int byteOrder = s.byteOrder();
 	    str.setLength( bytes/2 );
 	    QChar* ch = str.d->unicode;
 	    static const uint auto_size = 1024;
 	    char t[auto_size];
 	    char *b;
 	    if ( bytes > auto_size ) {
 		b = new char[bytes];
 	    } else {
 		b = t;
 	    }
 	    s.readRawBytes( b, bytes );
 	    int bt = bytes/2;
 	    char *oldb = b;
 	    while ( bt-- ) {
 		if ( byteOrder == QDataStream::BigEndian )
 		    *ch++ = (ushort) (((ushort)b[0])<<8) | (uchar)b[1];
 		else
 		    *ch++ = (ushort) (((ushort)b[1])<<8) | (uchar)b[0];
 		b += 2;
 	    }
 	    if ( bytes > auto_size )
 		delete [] oldb;
 	} else {
 	    str = "";
 	}
     }
     return s;
 }
 #endif // QT_NO_DATASTREAM
 
 /*****************************************************************************
   QConstString member functions
  *****************************************************************************/
 
 /*!
   \class QConstString qstring.h
   \reentrant
   \ingroup text
   \brief The QConstString class provides string objects using constant Unicode data.
 
     In order to minimize copying, highly optimized applications can
     use QConstString to provide a QString-compatible object from
     existing Unicode data. It is then the programmer's responsibility
     to ensure that the Unicode data exists for the entire lifetime of
     the QConstString object.
 
     A QConstString is created with the QConstString constructor. The
     string held by the object can be obtained by calling string().
 */
 
 /*!
     Constructs a QConstString that uses the first \a length Unicode
     characters in the array \a unicode. Any attempt to modify copies
     of the string will cause it to create a copy of the data, thus it
     remains forever unmodified.
 
     The data in \a unicode is not copied. The caller must be able to
     guarantee that \a unicode will not be deleted or modified.
 */
 QConstString::QConstString( const QChar* unicode, uint length ) :
     QString( new QStringData( (QChar*)unicode, length, length ), TRUE )
 {
 }
 
 /*!
     Destroys the QConstString, creating a copy of the data if other
     strings are still using it.
 */
 QConstString::~QConstString()
 {
     if ( d->count > 1 ) {
 	QChar* cp = QT_ALLOC_QCHAR_VEC( d->len );
 	memcpy( cp, d->unicode, d->len*sizeof(QChar) );
 	d->unicode = cp;
     } else {
 	d->unicode = 0;
     }
 
     // The original d->unicode is now unlinked.
 }
 
 /*!
     \fn const QString& QConstString::string() const
 
     Returns a constant string referencing the data passed during
     construction.
 */
 
 /*!
     Returns TRUE if the string starts with \a s; otherwise returns
     FALSE.
 
     \code
 	QString string("Bananas");
 	bool a = string.startsWith("Ban");      //  a == TRUE
     \endcode
 
     \sa endsWith()
 */
 bool QString::startsWith( const QString& s ) const
 {
     if ( isNull() )
 	return s.isNull();
     if ( s.length() > length() )
 	return FALSE;
     for ( int i =0; i < (int) s.length(); i++ ) {
 	if ( d->unicode[i] != s[i] )
 	    return FALSE;
     }
     return TRUE;
 }
 
 /*!
     Returns TRUE if the string ends with \a s; otherwise returns
     FALSE.
 
     \sa startsWith()
 */
 bool QString::endsWith( const QString& s ) const
 {
     if ( isNull() )
 	return s.isNull();
     int pos = length() - s.length();
     if ( pos < 0 )
 	return FALSE;
     for ( uint i = 0; i < s.length(); i++ ) {
 	if ( d->unicode[pos+i] != s[(int)i] )
 	    return FALSE;
     }
     return TRUE;
 }
 
 /*! \fn void QString::detach()
   If the string does not share its data with another QString instance,
   nothing happens; otherwise the function creates a new, unique copy of
   this string. This function is called whenever the map is modified. The
   implicit sharing mechanism is implemented this way.
 */
 
 #if defined(Q_OS_WIN32)
 
 #include <windows.h>
 
 /*!
   \obsolete
 
   Returns a static Windows TCHAR* from a QString, adding NUL if \a
   addnul is TRUE.
 
   The lifetime of the return value is until the next call to this function,
   or until the last copy of str is deleted, whatever comes first.
 
   Use ucs2() instead.
 */
 const void* qt_winTchar(const QString& str, bool)
 {
     // So that the return value lives long enough.
     static QString str_cache;
     str_cache = str;
 #ifdef UNICODE
     return str_cache.ucs2();
 #else
     return str_cache.latin1();
 #endif
 }
 
 /*!
     Makes a new '\0'-terminated Windows TCHAR* from a QString.
 */
 void* qt_winTchar_new(const QString& str)
 {
     if ( str.isNull() )
 	return 0;
     int l = str.length()+1;
     TCHAR *tc = new TCHAR[ l ];
 #ifdef UNICODE
     memcpy( tc, str.ucs2(), sizeof(TCHAR)*l );
 #else
     memcpy( tc, str.latin1(), sizeof(TCHAR)*l );
 #endif
     return tc;
 }
 
 /*!
     Makes a QString from a Windows TCHAR*.
 */
 QString qt_winQString(void* tc)
 {
 #ifdef UNICODE
     return QString::fromUcs2( (ushort*)tc );
 #else
     return QString::fromLatin1( (TCHAR *)tc );
 #endif
 }
 
 QCString qt_winQString2MB( const QString& s, int uclen )
 {
     if ( uclen < 0 )
 	uclen = s.length();
     if ( s.isNull() )
 	return QCString();
     if ( uclen == 0 )
 	return QCString("");
     BOOL used_def;
     QCString mb(4096);
     int len;
     while ( !(len=WideCharToMultiByte(CP_ACP, 0, (const WCHAR*)s.unicode(), uclen,
 		mb.data(), mb.size()-1, 0, &used_def)) )
     {
 	int r = GetLastError();
 	if ( r == ERROR_INSUFFICIENT_BUFFER ) {
 	    mb.resize(1+WideCharToMultiByte( CP_ACP, 0,
 				(const WCHAR*)s.unicode(), uclen,
 				0, 0, 0, &used_def));
 		// and try again...
 	} else {
 #ifndef QT_NO_DEBUG
 	    // Fail.
 	    qWarning("WideCharToMultiByte cannot convert multibyte text (error %d): %s (UTF8)",
 		r, s.utf8().data());
 #endif
 	    break;
 	}
     }
     mb[len]='\0';
     return mb;
 }
 
 // WATCH OUT: mblen must include the NUL (or just use -1)
 QString qt_winMB2QString( const char* mb, int mblen )
 {
     if ( !mb || !mblen )
 	return QString::null;
     const int wclen_auto = 4096;
     WCHAR wc_auto[wclen_auto];
     int wclen = wclen_auto;
     WCHAR *wc = wc_auto;
     int len;
     while ( !(len=MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED,
 		mb, mblen, wc, wclen )) )
     {
 	int r = GetLastError();
 	if ( r == ERROR_INSUFFICIENT_BUFFER ) {
 	    if ( wc != wc_auto ) {
 		qWarning("Size changed in MultiByteToWideChar");
 		break;
 	    } else {
 		wclen = MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED,
 				    mb, mblen, 0, 0 );
 		wc = new WCHAR[wclen];
 		// and try again...
 	    }
 	} else {
 	    // Fail.
 	    qWarning("MultiByteToWideChar cannot convert multibyte text");
 	    break;
 	}
     }
     if ( len <= 0 )
 	return QString::null;
     QString s( (QChar*)wc, len - 1 ); // len - 1: we don't want terminator
     if ( wc != wc_auto )
 	delete [] wc;
     return s;
 }
 
 #endif // Q_OS_WIN32
diff --git a/qmake/tools/qtextstream.cpp b/qmake/tools/qtextstream.cpp
index 75c6531..ddca5bd 100644
--- a/qmake/tools/qtextstream.cpp
+++ b/qmake/tools/qtextstream.cpp
@@ -1,2593 +1,2593 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QTextStream class
 **
 ** Created : 940922
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qtextstream.h"
 
 #ifndef QT_NO_TEXTSTREAM
 #include "qtextcodec.h"
 #include "qregexp.h"
 #include "qbuffer.h"
 #include "qfile.h"
 #include <stdio.h>
 #include <ctype.h>
 #include <stdlib.h>
 
 #if defined(Q_OS_WIN32)
 #include <windows.h>
 #endif
 
 /*!
     \class QTextStream qtextstream.h
     \reentrant
     \brief The QTextStream class provides basic functions for reading
     and writing text using a QIODevice.
 
     \ingroup io
     \ingroup text
     \mainclass
 
     The text stream class has a functional interface that is very
     similar to that of the standard C++ iostream class.
 
     Qt provides several global functions similar to the ones in iostream:
     \table
     \header \i Function \i Meaning
     \row \i bin \i sets the QTextStream to read/write binary numbers
     \row \i oct \i sets the QTextStream to read/write octal numbers
     \row \i dec \i sets the QTextStream to read/write decimal numbers
     \row \i hex \i sets the QTextStream to read/write hexadecimal numbers
     \row \i endl \i forces a line break
     \row \i flush \i forces the QIODevice to flush any buffered data
     \row \i ws \i eats any available whitespace (on input)
     \row \i reset \i resets the QTextStream to its default mode (see reset())
     \row \i qSetW(int) \i sets the \link width() field width \endlink
     to the given argument
     \row \i qSetFill(int) \i sets the \link fill() fill character
     \endlink to the given argument
     \row \i qSetPrecision(int) \i sets the \link precision() precision
     \endlink to the given argument
     \endtable
 
     \warning By default QTextStream will automatically detect whether
     integers in the stream are in decimal, octal, hexadecimal or
     binary format when reading from the stream. In particular, a
     leading '0' signifies octal, i.e. the sequence "0100" will be
     interpreted as 64.
 
     The QTextStream class reads and writes text; it is not appropriate
     for dealing with binary data (but QDataStream is).
 
     By default, output of Unicode text (i.e. QString) is done using
     the local 8-bit encoding. This can be changed using the
     setEncoding() method. For input, the QTextStream will auto-detect
     standard Unicode "byte order marked" text files; otherwise the
     local 8-bit encoding is used.
 
     The QIODevice is set in the constructor, or later using
     setDevice(). If the end of the input is reached atEnd() returns
     TRUE. Data can be read into variables of the appropriate type
     using the operator>>() overloads, or read in its entirety into a
     single string using read(), or read a line at a time using
     readLine(). Whitespace can be skipped over using skipWhiteSpace().
     You can set flags for the stream using flags() or setf(). The
     stream also supports width(), precision() and fill(); use reset()
     to reset the defaults.
 
     \sa QDataStream
 */
 
 /*!
     \enum QTextStream::Encoding
 
     \value Locale
     \value Latin1
     \value Unicode
     \value UnicodeNetworkOrder
     \value UnicodeReverse
     \value RawUnicode
     \value UnicodeUTF8
 
     See setEncoding() for an explanation of the encodings.
 */
 
 /*
   \class QTSManip
 
   \brief The QTSManip class is an internal helper class for the
   QTextStream.
 
   It is generally a very bad idea to use this class directly in
   application programs.
 
   \internal
 
   This class makes it possible to give the QTextStream function objects
   with arguments, like this:
   \code
     QTextStream cout( stdout, IO_WriteOnly );
     cout << setprecision( 8 );		// QTSManip used here!
     cout << 3.14159265358979323846;
   \endcode
 
   The setprecision() function returns a QTSManip object.
   The QTSManip object contains a pointer to a member function in
   QTextStream and an integer argument.
   When serializing a QTSManip into a QTextStream, the function
   is executed with the argument.
 */
 
 /*! \fn QTSManip::QTSManip( QTSMFI m, int a )
 
   Constructs a QTSManip object which will call \a m (a member function
   in QTextStream which accepts a single int) with argument \a a when
   QTSManip::exec() is called. Used internally in e.g. endl:
 
   \code
     s << "some text" << endl << "more text";
   \endcode
 */
 
 /*! \fn void QTSManip::exec( QTextStream& s )
 
   Calls the member function specified in the constructor, for object
   \a s. Used internally in e.g. endl:
 
   \code
     s << "some text" << endl << "more text";
   \endcode
 */
 
 
 /*****************************************************************************
   QTextStream member functions
  *****************************************************************************/
 
 #if defined(QT_CHECK_STATE)
 #undef  CHECK_STREAM_PRECOND
 #define CHECK_STREAM_PRECOND  if ( !dev ) {				\
 				qWarning( "QTextStream: No device" );	\
 				return *this; }
 #else
 #define CHECK_STREAM_PRECOND
 #endif
 
 
 #define I_SHORT		0x0010
 #define I_INT		0x0020
 #define I_LONG		0x0030
 #define I_TYPE_MASK	0x00f0
 
 #define I_BASE_2	QTS::bin
 #define I_BASE_8	QTS::oct
 #define I_BASE_10	QTS::dec
 #define I_BASE_16	QTS::hex
 #define I_BASE_MASK	(QTS::bin | QTS::oct | QTS::dec | QTS::hex)
 
 #define I_SIGNED	0x0100
 #define I_UNSIGNED	0x0200
 #define I_SIGN_MASK	0x0f00
 
 
 static const QChar QEOF = QChar((ushort)0xffff); //guaranteed not to be a character.
 static const uint getline_buf_size = 256; // bufsize used by ts_getline()
 
 const int QTextStream::basefield   = I_BASE_MASK;
 const int QTextStream::adjustfield = ( QTextStream::left |
 				       QTextStream::right |
 				       QTextStream::internal );
 const int QTextStream::floatfield  = ( QTextStream::scientific |
 				       QTextStream::fixed );
 
 
 class QTextStreamPrivate {
 public:
 #ifndef QT_NO_TEXTCODEC
     QTextStreamPrivate()
 	: decoder( 0 ), encoder( 0 ), sourceType( NotSet ) { }
     ~QTextStreamPrivate() {
 	delete decoder;
 	delete encoder;
     }
     QTextDecoder *decoder;
     QTextEncoder *encoder;
 #else
     QTextStreamPrivate() : sourceType( NotSet ) { }
     ~QTextStreamPrivate() { }
 #endif
     QString ungetcBuf;
 
     enum SourceType { NotSet, IODevice, String, ByteArray, File };
     SourceType sourceType;
 };
 
 
 // skips whitespace and returns the first non-whitespace character
 QChar QTextStream::eat_ws()
 {
     QChar c;
     do { c = ts_getc(); } while ( c != QEOF && ts_isspace(c) );
     return c;
 }
 
 void QTextStream::init()
 {
     // ### ungetcBuf = QEOF;
     dev = 0;
     owndev = FALSE;
     mapper = 0;
     d = new QTextStreamPrivate;
     doUnicodeHeader = TRUE; // autodetect
     latin1 = TRUE; // should use locale?
     internalOrder = QChar::networkOrdered();
     networkOrder = TRUE;
 }
 
 /*!
     Constructs a data stream that has no IO device.
 */
 
 QTextStream::QTextStream()
 {
     init();
     setEncoding( Locale ); //###
     reset();
     d->sourceType = QTextStreamPrivate::NotSet;
 }
 
 /*!
     Constructs a text stream that uses the IO device \a iod.
 */
 
 QTextStream::QTextStream( QIODevice *iod )
 {
     init();
     setEncoding( Locale ); //###
     dev = iod;
     reset();
     d->sourceType = QTextStreamPrivate::IODevice;
 }
 
 // TODO: use special-case handling of this case in QTextStream, and
 //	 simplify this class to only deal with QChar or QString data.
 class QStringBuffer : public QIODevice {
 public:
     QStringBuffer( QString* str );
     ~QStringBuffer();
     bool  open( int m );
     void  close();
     void  flush();
     Offset  size() const;
     Offset  at()   const;
     bool  at( Offset pos );
     Q_LONG readBlock( char *p, Q_ULONG len );
     Q_LONG writeBlock( const char *p, Q_ULONG len );
     int   getch();
     int   putch( int ch );
     int   ungetch( int ch );
 protected:
     QString* s;
 
 private:        // Disabled copy constructor and operator=
     QStringBuffer( const QStringBuffer & );
     QStringBuffer &operator=( const QStringBuffer & );
 };
 
 
 QStringBuffer::QStringBuffer( QString* str )
 {
     s = str;
 }
 
 QStringBuffer::~QStringBuffer()
 {
 }
 
 
 bool QStringBuffer::open( int m )
 {
     if ( !s ) {
 #if defined(QT_CHECK_STATE)
 	qWarning( "QStringBuffer::open: No string" );
 #endif
 	return FALSE;
     }
     if ( isOpen() ) {                           // buffer already open
 #if defined(QT_CHECK_STATE)
 	qWarning( "QStringBuffer::open: Buffer already open" );
 #endif
 	return FALSE;
     }
     setMode( m );
     if ( m & IO_Truncate ) {                    // truncate buffer
 	s->truncate( 0 );
     }
     if ( m & IO_Append ) {                      // append to end of buffer
 	ioIndex = s->length()*sizeof(QChar);
     } else {
 	ioIndex = 0;
     }
     setState( IO_Open );
     setStatus( 0 );
     return TRUE;
 }
 
 void QStringBuffer::close()
 {
     if ( isOpen() ) {
 	setFlags( IO_Direct );
 	ioIndex = 0;
     }
 }
 
 void QStringBuffer::flush()
 {
 }
 
 QIODevice::Offset QStringBuffer::size() const
 {
     return s ? s->length()*sizeof(QChar) : 0;
 }
 
 QIODevice::Offset  QStringBuffer::at()   const
 {
     return ioIndex;
 }
 
 bool QStringBuffer::at( Offset pos )
 {
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {
 	qWarning( "QStringBuffer::at: Buffer is not open" );
 	return FALSE;
     }
 #endif
     if ( pos >= s->length()*2 ) {
 #if defined(QT_CHECK_RANGE)
 #if defined(QT_LARGEFILE_SUPPORT) && defined(QT_ABI_64BITOFFSET)
 	qWarning( "QStringBuffer::at: Index %llu out of range", pos );
 #else
 	qWarning( "QStringBuffer::at: Index %lu out of range", pos );
 #endif
 #endif
 	return FALSE;
     }
     ioIndex = pos;
     return TRUE;
 }
 
 
 Q_LONG QStringBuffer::readBlock( char *p, Q_ULONG len )
 {
 #if defined(QT_CHECK_STATE)
     Q_CHECK_PTR( p );
     if ( !isOpen() ) {                          // buffer not open
 	qWarning( "QStringBuffer::readBlock: Buffer not open" );
 	return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
 	qWarning( "QStringBuffer::readBlock: Read operation not permitted" );
 	return -1;
     }
 #endif
     if ( ioIndex + len > s->length()*sizeof(QChar) ) {
 	// overflow
 	if ( (uint)ioIndex >= s->length()*sizeof(QChar) ) {
 	    setStatus( IO_ReadError );
 	    return -1;
 	} else {
 	    len = s->length()*2 - (uint)ioIndex;
 	}
     }
     memcpy( p, ((const char*)(s->unicode()))+ioIndex, len );
     ioIndex += len;
     return len;
 }
 
 Q_LONG QStringBuffer::writeBlock( const char *p, Q_ULONG len )
 {
 #if defined(QT_CHECK_NULL)
     if ( p == 0 && len != 0 )
 	qWarning( "QStringBuffer::writeBlock: Null pointer error" );
 #endif
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
 	qWarning( "QStringBuffer::writeBlock: Buffer not open" );
 	return -1;
     }
     if ( !isWritable() ) {                      // writing not permitted
 	qWarning( "QStringBuffer::writeBlock: Write operation not permitted" );
 	return -1;
     }
     if ( ioIndex&1 ) {
 	qWarning( "QStringBuffer::writeBlock: non-even index - non Unicode" );
 	return -1;
     }
     if ( len&1 ) {
 	qWarning( "QStringBuffer::writeBlock: non-even length - non Unicode" );
 	return -1;
     }
 #endif
     s->replace(ioIndex/2, len/2, (QChar*)p, len/2);
     ioIndex += len;
     return len;
 }
 
 int QStringBuffer::getch()
 {
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
 	qWarning( "QStringBuffer::getch: Buffer not open" );
 	return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
 	qWarning( "QStringBuffer::getch: Read operation not permitted" );
 	return -1;
     }
 #endif
     if ( (uint)ioIndex >= s->length()*2 ) {           // overflow
 	setStatus( IO_ReadError );
 	return -1;
     }
     return (int) *( (const char *) s->unicode() + ioIndex++ );
 }
 
 int QStringBuffer::putch( int ch )
 {
     char c = ch;
     if ( writeBlock(&c,1) < 0 )
 	return -1;
     else
 	return ch;
 }
 
 int QStringBuffer::ungetch( int ch )
 {
 #if defined(QT_CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
 	qWarning( "QStringBuffer::ungetch: Buffer not open" );
 	return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
 	qWarning( "QStringBuffer::ungetch: Read operation not permitted" );
 	return -1;
     }
 #endif
     if ( ch != -1 ) { // something to do with eof
 	if ( ioIndex )
 	    ioIndex--;
 	else
 	    ch = -1;
     }
     return ch;
 }
 
 
 /*!
     Constructs a text stream that operates on the Unicode QString, \a
     str, through an internal device. The \a filemode argument is
     passed to the device's open() function; see \l{QIODevice::mode()}.
 
     If you set an encoding or codec with setEncoding() or setCodec(),
     this setting is ignored for text streams that operate on QString.
 
     Example:
     \code
     QString str;
     QTextStream ts( &str, IO_WriteOnly );
     ts << "pi = " << 3.14; // str == "pi = 3.14"
     \endcode
 
     Writing data to the text stream will modify the contents of the
     string. The string will be expanded when data is written beyond
     the end of the string. Note that the string will not be truncated:
     \code
     QString str = "pi = 3.14";
     QTextStream ts( &str, IO_WriteOnly );
     ts <<  "2+2 = " << 2+2; // str == "2+2 = 414"
     \endcode
 
     Note that because QString is Unicode, you should not use
     readRawBytes() or writeRawBytes() on such a stream.
 */
 
 QTextStream::QTextStream( QString* str, int filemode )
 {
     // TODO: optimize for this case as it becomes more common
     //        (see QStringBuffer above)
     init();
     dev = new QStringBuffer( str );
     ((QStringBuffer *)dev)->open( filemode );
     owndev = TRUE;
     setEncoding(RawUnicode);
     reset();
     d->sourceType = QTextStreamPrivate::String;
 }
 
 /*! \obsolete
 
   This constructor is equivalent to the constructor taking a QString*
   parameter.
 */
 
 QTextStream::QTextStream( QString& str, int filemode )
 {
     init();
     dev = new QStringBuffer( &str );
     ((QStringBuffer *)dev)->open( filemode );
     owndev = TRUE;
     setEncoding(RawUnicode);
     reset();
     d->sourceType = QTextStreamPrivate::String;
 }
 
 /*!
     Constructs a text stream that operates on the byte array, \a a,
     through an internal QBuffer device. The \a mode argument is passed
     to the device's open() function; see \l{QIODevice::mode()}.
 
     Example:
     \code
     QByteArray array;
     QTextStream ts( array, IO_WriteOnly );
     ts << "pi = " << 3.14 << '\0'; // array == "pi = 3.14"
     \endcode
 
     Writing data to the text stream will modify the contents of the
     array. The array will be expanded when data is written beyond the
     end of the string.
 
     Same example, using a QBuffer:
     \code
     QByteArray array;
     QBuffer buf( array );
     buf.open( IO_WriteOnly );
     QTextStream ts( &buf );
     ts << "pi = " << 3.14 << '\0'; // array == "pi = 3.14"
     buf.close();
     \endcode
 */
 
 QTextStream::QTextStream( QByteArray a, int mode )
 {
     init();
     dev = new QBuffer( a );
     ((QBuffer *)dev)->open( mode );
     owndev = TRUE;
     setEncoding( Latin1 ); //### Locale???
     reset();
     d->sourceType = QTextStreamPrivate::ByteArray;
 }
 
 /*!
     Constructs a text stream that operates on an existing file handle
     \a fh through an internal QFile device. The \a mode argument is
     passed to the device's open() function; see \l{QIODevice::mode()}.
 
     Note that if you create a QTextStream \c cout or another name that
     is also used for another variable of a different type, some
     linkers may confuse the two variables, which will often cause
     crashes.
 */
 
 QTextStream::QTextStream( FILE *fh, int mode )
 {
     init();
     setEncoding( Locale ); //###
     dev = new QFile;
     ((QFile *)dev)->open( mode, fh );
     owndev = TRUE;
     reset();
     d->sourceType = QTextStreamPrivate::File;
 }
 
 /*!
     Destroys the text stream.
 
     The destructor does not affect the current IO device.
 */
 
 QTextStream::~QTextStream()
 {
     if ( owndev )
 	delete dev;
     delete d;
 }
 
 /*!
     Positions the read pointer at the first non-whitespace character.
 */
 void QTextStream::skipWhiteSpace()
 {
     ts_ungetc( eat_ws() );
 }
 
 
 /*!
     Tries to read \a len characters from the stream and stores them in
     \a buf. Returns the number of characters really read.
 
     \warning There will no QEOF appended if the read reaches the end
     of the file. EOF is reached when the return value does not equal
     \a len.
 */
 uint QTextStream::ts_getbuf( QChar* buf, uint len )
 {
     if( len < 1 )
 	return 0;
 
     uint rnum=0;   // the number of QChars really read
 
     if ( d && d->ungetcBuf.length() ) {
 	while( rnum < len && rnum < d->ungetcBuf.length() ) {
 	    *buf = d->ungetcBuf.constref( rnum );
 	    buf++;
 	    rnum++;
 	}
 	d->ungetcBuf = d->ungetcBuf.mid( rnum );
 	if ( rnum >= len )
 	    return rnum;
     }
 
     // we use dev->ungetch() for one of the bytes of the unicode
     // byte-order mark, but a local unget hack for the other byte:
     int ungetHack = EOF;
 
     if ( doUnicodeHeader ) {
 	doUnicodeHeader = FALSE; // only at the top
 	int c1 = dev->getch();
 	if ( c1 == EOF )
 	    return rnum;
 	int c2 = dev->getch();
 	if ( c1 == 0xfe && c2 == 0xff ) {
 	    mapper = 0;
 	    latin1 = FALSE;
 	    internalOrder = QChar::networkOrdered();
 	    networkOrder = TRUE;
 	} else if ( c1 == 0xff && c2 == 0xfe ) {
 	    mapper = 0;
 	    latin1 = FALSE;
 	    internalOrder = !QChar::networkOrdered();
 	    networkOrder = FALSE;
 	} else {
 	    if ( c2 != EOF ) {
 	 	dev->ungetch( c2 );
 		ungetHack = c1;
 	    } else {
 		/*
 		  A small bug might hide here. If only the first byte
 		  of a file has made it so far, and that first byte
 		  is half of the byte-order mark, then the utfness
 		  will not be detected.
 		*/
 	 	dev->ungetch( c1 );
 	    }
 	}
     }
 
 #ifndef QT_NO_TEXTCODEC
     if ( mapper ) {
 	bool shortRead = FALSE;
 	if ( !d->decoder )
 	    d->decoder = mapper->makeDecoder();
 	while( rnum < len ) {
 	    QString s;
 	    bool readBlock = !( len == 1+rnum );
 	    for (;;) {
 		// for efficiency: normally read a whole block
 		if ( readBlock ) {
 		    // guess buffersize; this may be wrong (too small or too
 		    // big). But we can handle this (either iterate reading
 		    // or use ungetcBuf).
 		    // Note that this might cause problems for codecs where
 		    // one byte can result in >1 Unicode Characters if bytes
 		    // are written to the stream in the meantime (loss of
 		    // synchronicity).
 		    uint rlen = len - rnum;
 		    char *cbuf = new char[ rlen ];
 		    if ( ungetHack != EOF ) {
 			rlen = 1+dev->readBlock( cbuf+1, rlen-1 );
 			cbuf[0] = (char)ungetHack;
 			ungetHack = EOF;
 		    } else {
 			rlen = dev->readBlock( cbuf, rlen );
 		    }
 		    s  += d->decoder->toUnicode( cbuf, rlen );
 		    delete[] cbuf;
 		    // use buffered reading only for the first time, because we
 		    // have to get the stream synchronous again (this is easier
 		    // with single character reading)
 		    readBlock = FALSE;
 		}
 		// get stream (and codec) in sync
 		int c;
 		if ( ungetHack == EOF ) {
 		    c = dev->getch();
 		} else {
 		    c = ungetHack;
 		    ungetHack = EOF;
 		}
 		if ( c == EOF ) {
 		    shortRead = TRUE;
 		    break;
 		}
 		char b = c;
 		uint lengthBefore = s.length();
 		s  += d->decoder->toUnicode( &b, 1 );
 		if ( s.length() > lengthBefore )
 		    break; // it seems we are in sync now
 	    }
 	    uint i = 0;
 	    uint end = QMIN( len-rnum, s.length() );
 	    while( i < end ) {
 		*buf = s.constref(i++);
 		buf++;
 	    }
 	    rnum += end;
 	    if ( s.length() > i )
 		// could be = but append is clearer
 		d->ungetcBuf.append( s.mid( i ) );
 	    if ( shortRead )
 		return rnum;
 	}
     } else
 #endif
     if ( latin1 ) {
 	if ( len == 1+rnum ) {
 	    // use this method for one character because it is more efficient
 	    // (arnt doubts whether it makes a difference, but lets it stand)
 	    int c = (ungetHack == EOF) ? dev->getch() : ungetHack;
 	    if ( c != EOF ) {
 		*buf = (char)c;
 		buf++;
 		rnum++;
 	    }
 	} else {
 	    if ( ungetHack != EOF ) {
 		*buf = (char)ungetHack;
 		buf++;
 		rnum++;
 		ungetHack = EOF;
 	    }
 	    char *cbuf = new char[len - rnum];
 	    while ( !dev->atEnd() && rnum < len ) {
 		uint rlen = len - rnum;
 		rlen = dev->readBlock( cbuf, rlen );
 		char *it = cbuf;
 		char *end = cbuf + rlen;
 		while ( it < end ) {
 		    *buf = *it;
 		    buf++;
 		    it++;
 		}
 		rnum += rlen;
 	    }
 	    delete[] cbuf;
 	}
     } else { // UCS-2 or UTF-16
 	if ( len == 1+rnum ) {
 	    int c1 = (ungetHack == EOF) ? dev->getch() : ungetHack;
 	    if ( c1 == EOF )
 		return rnum;
 	    int c2 = dev->getch();
 	    if ( c2 == EOF )
 		return rnum;
 
 	    if ( networkOrder ) {
 		*buf = QChar( c2, c1 );
 	    } else {
 		*buf = QChar( c1, c2 );
 	    }
 	    buf++;
 	    rnum++;
 	} else {
 	    char *cbuf = new char[ 2*( len - rnum ) ]; // for paranoids: overflow possible
 	    while ( !dev->atEnd() && rnum < len ) {
 		uint rlen = 2 * ( len-rnum );
 		if ( ungetHack != EOF ) {
 		    rlen = 1+dev->readBlock( cbuf+1, rlen-1 );
 		    cbuf[0] = (char)ungetHack;
 		    ungetHack = EOF;
 		} else {
 		    rlen = dev->readBlock( cbuf, rlen );
 		}
 		// We can't use an odd number of bytes, so put it back. But
 		// do it only if we are capable of reading more -- normally
 		// there should not be an odd number, but the file might be
 		// truncated or not in UTF-16...
 		if ( (rlen & 1) == 1 )
 		    if ( !dev->atEnd() )
 			dev->ungetch( cbuf[--rlen] );
 		uint i = 0;
 		if ( networkOrder ) {
 		    while( i < rlen ) {
 			*buf = QChar( cbuf[i+1], cbuf[i] );
 			buf++;
 			i+=2;
 		    }
 		} else {
 		    while( i < rlen ) {
 			*buf = QChar( cbuf[i], cbuf[i+1] );
 			buf++;
 			i+=2;
 		    }
 		}
 		rnum += i/2;
 	    }
 	    delete[] cbuf;
 	}
     }
     return rnum;
 }
 
 /*!
     Tries to read one line, but at most len characters from the stream
     and stores them in \a buf.
 
     Returns the number of characters really read. Newlines are not
     stripped.
 
     There will be a QEOF appended if the read reaches the end of file;
     this is different to ts_getbuf().
 
     This function works only if a newline (as byte) is also a newline
     (as resulting character) since it uses QIODevice::readLine(). So
     use it only for such codecs where this is true!
 
     This function is (almost) a no-op for UTF 16. Don't use it if
     doUnicodeHeader is TRUE!
 */
 uint QTextStream::ts_getline( QChar* buf )
 {
     uint rnum=0;   // the number of QChars really read
     char cbuf[ getline_buf_size+1 ];
 
     if ( d && d->ungetcBuf.length() ) {
 	while( rnum < getline_buf_size && rnum < d->ungetcBuf.length() ) {
 	    buf[rnum] = d->ungetcBuf.constref(rnum);
 	    rnum++;
 	}
 	d->ungetcBuf = d->ungetcBuf.mid( rnum );
 	if ( rnum >= getline_buf_size )
 	    return rnum;
     }
 
 #ifndef QT_NO_TEXTCODEC
     if ( mapper ) {
 	if ( !d->decoder )
 	    d->decoder = mapper->makeDecoder();
 	QString s;
 	bool readBlock = TRUE;
 	for (;;) {
 	    // for efficiency: try to read a line
 	    if ( readBlock ) {
 		int rlen = getline_buf_size - rnum;
 		rlen = dev->readLine( cbuf, rlen+1 );
 		if ( rlen == -1 )
 		    rlen = 0;
 		s  += d->decoder->toUnicode( cbuf, rlen );
 		readBlock = FALSE;
 	    }
 	    if ( dev->atEnd()
 		    || s.at( s.length()-1 ) == '\n'
 		    || s.at( s.length()-1 ) == '\r'
 	       ) {
 		break;
 	    } else {
 		// get stream (and codec) in sync
 		int c;
 		c = dev->getch();
 		if ( c == EOF ) {
 		    break;
 		}
 		char b = c;
 		uint lengthBefore = s.length();
 		s  += d->decoder->toUnicode( &b, 1 );
 		if ( s.length() > lengthBefore )
 		    break; // it seems we are in sync now
 	    }
 	}
 	uint i = 0;
 	while( rnum < getline_buf_size && i < s.length() )
 	    buf[rnum++] = s.constref(i++);
 	if ( s.length() > i )
 	    // could be = but append is clearer
 	    d->ungetcBuf.append( s.mid( i ) );
 	if ( rnum < getline_buf_size && dev->atEnd() )
 	    buf[rnum++] = QEOF;
     } else
 #endif
     if ( latin1 ) {
 	int rlen = getline_buf_size - rnum;
 	rlen = dev->readLine( cbuf, rlen+1 );
 	if ( rlen == -1 )
 	    rlen = 0;
 	char *end = cbuf+rlen;
 	char *it = cbuf;
 	buf +=rnum;
 	while ( it != end ) {
 	    buf->setCell( *(it++) );
 	    buf->setRow( 0 );
 	    buf++;
 	}
 	rnum += rlen;
 	if ( rnum < getline_buf_size && dev->atEnd() )
 	    buf[1] = QEOF;
     }
     return rnum;
 }
 
 
 /*!
     Puts one character into the stream.
 */
 void QTextStream::ts_putc( QChar c )
 {
 #ifndef QT_NO_TEXTCODEC
     if ( mapper ) {
 	if ( !d->encoder )
 	    d->encoder = mapper->makeEncoder();
 	int len = 1;
 	QString s = c;
 	QCString block = d->encoder->fromUnicode( s, len );
 	dev->writeBlock( block, len );
     } else
 #endif
     if ( latin1 ) {
 	if ( c.row() )
 	    dev->putch( '?' ); // unknown character
 	else
 	    dev->putch( c.cell() );
     } else {
 	if ( doUnicodeHeader ) {
 	    doUnicodeHeader = FALSE;
 	    ts_putc( QChar::byteOrderMark );
 	}
 	if ( internalOrder ) {
 	    // this case is needed by QStringBuffer
 	    dev->writeBlock( (char*)&c, sizeof(QChar) );
 	} else if ( networkOrder ) {
 	    dev->putch( c.row() );
 	    dev->putch( c.cell() );
 	} else {
 	    dev->putch( c.cell() );
 	    dev->putch( c.row() );
 	}
     }
 }
 
 /*!
     Puts one character into the stream.
 */
 void QTextStream::ts_putc( int ch )
 {
     ts_putc( QChar((ushort)ch) );
 }
 
 bool QTextStream::ts_isdigit( QChar c )
 {
     return c.isDigit();
 }
 
 bool QTextStream::ts_isspace( QChar c )
 {
     return c.isSpace();
 }
 
 void QTextStream::ts_ungetc( QChar c )
 {
     if ( c.unicode() == 0xffff )
 	return;
 
     d->ungetcBuf.prepend( c );
 }
 
 
 
 /*!
     Reads \a len bytes from the stream into \a s and returns a
     reference to the stream.
 
     The buffer \a s must be preallocated.
 
     Note that no encoding is done by this function.
 
     \warning The behavior of this function is undefined unless the
     stream's encoding is set to Unicode or Latin1.
 
     \sa QIODevice::readBlock()
 */
 
 QTextStream &QTextStream::readRawBytes( char *s, uint len )
 {
     dev->readBlock( s, len );
     return *this;
 }
 
 /*!
     Writes the \a len bytes from \a s to the stream and returns a
     reference to the stream.
 
     Note that no encoding is done by this function.
 
     \sa QIODevice::writeBlock()
 */
 
 QTextStream &QTextStream::writeRawBytes( const char* s, uint len )
 {
     dev->writeBlock( s, len );
     return *this;
 }
 
 
 QTextStream &QTextStream::writeBlock( const char* p, uint len )
 {
     if ( doUnicodeHeader ) {
 	doUnicodeHeader = FALSE;
 	if ( !mapper && !latin1 )
 	    ts_putc( QChar::byteOrderMark );
     }
     // QCString and const char * are treated as Latin-1
     if ( !mapper && latin1 ) {
 	dev->writeBlock( p, len );
     } else if ( !mapper && internalOrder ) {
 	QChar *u = new QChar[len];
 	for ( uint i = 0; i < len; i++ )
 	    u[i] = p[i];
 	dev->writeBlock( (char*)u, len * sizeof(QChar) );
 	delete [] u;
     } else {
 	for ( uint i = 0; i < len; i++ )
 	    ts_putc( (uchar)p[i] );
     }
     return *this;
 }
 
 QTextStream &QTextStream::writeBlock( const QChar* p, uint len )
 {
 #ifndef QT_NO_TEXTCODEC
     if ( mapper ) {
 	if ( !d->encoder )
 	    d->encoder = mapper->makeEncoder();
 	QConstString s( p, len );
 	int l = len;
 	QCString block = d->encoder->fromUnicode( s.string(), l );
 	dev->writeBlock( block, l );
     } else
 #endif
     if ( latin1 ) {
-	char *str = QString::unicodeToAscii( p, len );
+	char *str = QString::unicodeToLatin1( p, len );
 	dev->writeBlock( str, len );
 	delete [] str;
     } else if ( internalOrder ) {
 	if ( doUnicodeHeader ) {
 	    doUnicodeHeader = FALSE;
 	    ts_putc( QChar::byteOrderMark );
 	}
 	dev->writeBlock( (char*)p, sizeof(QChar)*len );
     } else {
 	for (uint i=0; i<len; i++)
 	    ts_putc( p[i] );
     }
     return *this;
 }
 
 /*!
     Resets the text stream.
 
     \list
     \i All flags are set to 0.
     \i The field width is set to 0.
     \i The fill character is set to ' ' (Space).
     \i The precision is set to 6.
     \endlist
 
     \sa setf(), width(), fill(), precision()
 */
 
 void QTextStream::reset()
 {
     fflags = 0;
     fwidth = 0;
     fillchar = ' ';
     fprec = 6;
 }
 
 /*!
     \fn QIODevice *QTextStream::device() const
 
     Returns the IO device currently set.
 
     \sa setDevice(), unsetDevice()
 */
 
 /*!
     Sets the IO device to \a iod.
 
     \sa device(), unsetDevice()
 */
 
 void QTextStream::setDevice( QIODevice *iod )
 {
     if ( owndev ) {
 	delete dev;
 	owndev = FALSE;
     }
     dev = iod;
     d->sourceType = QTextStreamPrivate::IODevice;
 }
 
 /*!
     Unsets the IO device. Equivalent to setDevice( 0 ).
 
     \sa device(), setDevice()
 */
 
 void QTextStream::unsetDevice()
 {
     setDevice( 0 );
     d->sourceType = QTextStreamPrivate::NotSet;
 }
 
 /*!
     \fn bool QTextStream::atEnd() const
 
     Returns TRUE if the IO device has reached the end position (end of
     the stream or file) or if there is no IO device set; otherwise
     returns FALSE.
 
     \sa QIODevice::atEnd()
 */
 
 /*!\fn bool QTextStream::eof() const
 
   \obsolete
 
   This function has been renamed to atEnd().
 
   \sa QIODevice::atEnd()
 */
 
 /*****************************************************************************
   QTextStream read functions
  *****************************************************************************/
 
 
 /*!
     \overload
 
     Reads a char \a c from the stream and returns a reference to the
     stream. Note that whitespace is skipped.
 */
 
 QTextStream &QTextStream::operator>>( char &c )
 {
     CHECK_STREAM_PRECOND
     c = eat_ws();
     return *this;
 }
 
 /*!
     Reads a char \a c from the stream and returns a reference to the
     stream. Note that whitespace is \e not skipped.
 */
 
 QTextStream &QTextStream::operator>>( QChar &c )
 {
     CHECK_STREAM_PRECOND
     c = ts_getc();
     return *this;
 }
 
 
 ulong QTextStream::input_bin()
 {
     ulong val = 0;
     QChar ch = eat_ws();
     int dv = ch.digitValue();
     while (  dv == 0 || dv == 1 ) {
 	val = ( val << 1 ) + dv;
 	ch = ts_getc();
 	dv = ch.digitValue();
     }
     if ( ch != QEOF )
 	ts_ungetc( ch );
     return val;
 }
 
 ulong QTextStream::input_oct()
 {
     ulong val = 0;
     QChar ch = eat_ws();
     int dv = ch.digitValue();
     while ( dv >= 0 && dv <= 7 ) {
 	val = ( val << 3 ) + dv;
 	ch = ts_getc();
 	dv = ch.digitValue();
     }
     if ( dv == 8 || dv == 9 ) {
 	while ( ts_isdigit(ch) )
 	    ch = ts_getc();
     }
     if ( ch != QEOF )
 	ts_ungetc( ch );
     return val;
 }
 
 ulong QTextStream::input_dec()
 {
     ulong val = 0;
     QChar ch = eat_ws();
     int dv = ch.digitValue();
     while ( ts_isdigit(ch) ) {
 	val = val * 10 + dv;
 	ch = ts_getc();
 	dv = ch.digitValue();
     }
     if ( ch != QEOF )
 	ts_ungetc( ch );
     return val;
 }
 
 ulong QTextStream::input_hex()
 {
     ulong val = 0;
     QChar ch = eat_ws();
     char c = ch;
     while ( isxdigit((uchar) c) ) {
 	val <<= 4;
 	if ( ts_isdigit(c) )
 	    val += c - '0';
 	else
 	    val += 10 + tolower( (uchar) c ) - 'a';
 	c = ch = ts_getc();
     }
     if ( ch != QEOF )
 	ts_ungetc( ch );
     return val;
 }
 
 long QTextStream::input_int()
 {
     long val;
     QChar ch;
     char c;
     switch ( flags() & basefield ) {
     case bin:
 	val = (long)input_bin();
 	break;
     case oct:
 	val = (long)input_oct();
 	break;
     case dec:
 	c = ch = eat_ws();
 	if ( ch == QEOF ) {
 	    val = 0;
 	} else {
 	    if ( !(c == '-' || c == '+') )
 		ts_ungetc( ch );
 	    if ( c == '-' ) {
 		ulong v = input_dec();
 		if ( v ) {		// ensure that LONG_MIN can be read
 		    v--;
 		    val = -((long)v) - 1;
 		} else {
 		    val = 0;
 		}
 	    } else {
 		val = (long)input_dec();
 	    }
 	}
 	break;
     case hex:
 	val = (long)input_hex();
 	break;
     default:
 	val = 0;
 	c = ch = eat_ws();
 	if ( c == '0' ) {		// bin, oct or hex
 	    c = ch = ts_getc();
 	    if ( tolower((uchar) c) == 'x' )
 		val = (long)input_hex();
 	    else if ( tolower((uchar) c) == 'b' )
 		val = (long)input_bin();
 	    else {			// octal
 		ts_ungetc( ch );
 		if ( c >= '0' && c <= '7' ) {
 		    val = (long)input_oct();
 		} else {
 		    val = 0;
 		}
 	    }
 	} else if ( ts_isdigit(ch) ) {
 	    ts_ungetc( ch );
 	    val = (long)input_dec();
 	} else if ( c == '-' || c == '+' ) {
 	    ulong v = input_dec();
 	    if ( c == '-' ) {
 		if ( v ) {		// ensure that LONG_MIN can be read
 		    v--;
 		    val = -((long)v) - 1;
 		} else {
 		    val = 0;
 		}
 	    } else {
 		val = (long)v;
 	    }
 	}
     }
     return val;
 }
 
 //
 // We use a table-driven FSM to parse floating point numbers
 // strtod() cannot be used directly since we're reading from a QIODevice
 //
 
 double QTextStream::input_double()
 {
     const int Init	 = 0;			// states
     const int Sign	 = 1;
     const int Mantissa	 = 2;
     const int Dot	 = 3;
     const int Abscissa	 = 4;
     const int ExpMark	 = 5;
     const int ExpSign	 = 6;
     const int Exponent	 = 7;
     const int Done	 = 8;
 
     const int InputSign	 = 1;			// input tokens
     const int InputDigit = 2;
     const int InputDot	 = 3;
     const int InputExp	 = 4;
 
     static const uchar table[8][5] = {
      /* None	 InputSign   InputDigit InputDot InputExp */
 	{ 0,	    Sign,     Mantissa,	 Dot,	   0,	   }, // Init
 	{ 0,	    0,	      Mantissa,	 Dot,	   0,	   }, // Sign
 	{ Done,	    Done,     Mantissa,	 Dot,	   ExpMark,}, // Mantissa
 	{ 0,	    0,	      Abscissa,	 0,	   0,	   }, // Dot
 	{ Done,	    Done,     Abscissa,	 Done,	   ExpMark,}, // Abscissa
 	{ 0,	    ExpSign,  Exponent,	 0,	   0,	   }, // ExpMark
 	{ 0,	    0,	      Exponent,	 0,	   0,	   }, // ExpSign
 	{ Done,	    Done,     Exponent,	 Done,	   Done	   }  // Exponent
     };
 
     int state = Init;				// parse state
     int input;					// input token
 
     char buf[256];
     int i = 0;
     QChar c = eat_ws();
 
     for (;;) {
 
 	switch ( c ) {
 	    case '+':
 	    case '-':
 		input = InputSign;
 		break;
 	    case '0': case '1': case '2': case '3': case '4':
 	    case '5': case '6': case '7': case '8': case '9':
 		input = InputDigit;
 		break;
 	    case '.':
 		input = InputDot;
 		break;
 	    case 'e':
 	    case 'E':
 		input = InputExp;
 		break;
 	    default:
 		input = 0;
 		break;
 	}
 
 	state = table[state][input];
 
 	if  ( state == 0 || state == Done || i > 250 ) {
 	    if ( i > 250 ) {			// ignore rest of digits
 		do { c = ts_getc(); } while ( c != QEOF && ts_isdigit(c) );
 	    }
 	    if ( c != QEOF )
 		ts_ungetc( c );
 	    buf[i] = '\0';
 	    char *end;
 	    return strtod( buf, &end );
 	}
 
 	buf[i++] = c;
 	c = ts_getc();
     }
 
 #if !defined(Q_CC_EDG)
     return 0.0;
 #endif
 }
 
 
 /*!
     \overload
 
     Reads a signed \c short integer \a i from the stream and returns a
     reference to the stream. See flags() for an explanation of the
     expected input format.
 */
 
 QTextStream &QTextStream::operator>>( signed short &i )
 {
     CHECK_STREAM_PRECOND
     i = (signed short)input_int();
     return *this;
 }
 
 
 /*!
     \overload
 
     Reads an unsigned \c short integer \a i from the stream and
     returns a reference to the stream. See flags() for an explanation
     of the expected input format.
 */
 
 QTextStream &QTextStream::operator>>( unsigned short &i )
 {
     CHECK_STREAM_PRECOND
     i = (unsigned short)input_int();
     return *this;
 }
 
 
 /*!
     \overload
 
     Reads a signed \c int \a i from the stream and returns a reference
     to the stream. See flags() for an explanation of the expected
     input format.
 */
 
 QTextStream &QTextStream::operator>>( signed int &i )
 {
     CHECK_STREAM_PRECOND
     i = (signed int)input_int();
     return *this;
 }
 
 
 /*!
     \overload
 
     Reads an unsigned \c int \a i from the stream and returns a
     reference to the stream. See flags() for an explanation of the
     expected input format.
 */
 
 QTextStream &QTextStream::operator>>( unsigned int &i )
 {
     CHECK_STREAM_PRECOND
     i = (unsigned int)input_int();
     return *this;
 }
 
 
 /*!
     \overload
 
     Reads a signed \c long int \a i from the stream and returns a
     reference to the stream. See flags() for an explanation of the
     expected input format.
 */
 
 QTextStream &QTextStream::operator>>( signed long &i )
 {
     CHECK_STREAM_PRECOND
     i = (signed long)input_int();
     return *this;
 }
 
 
 /*!
     \overload
 
     Reads an unsigned \c long int \a i from the stream and returns a
     reference to the stream. See flags() for an explanation of the
     expected input format.
 */
 
 QTextStream &QTextStream::operator>>( unsigned long &i )
 {
     CHECK_STREAM_PRECOND
     i = (unsigned long)input_int();
     return *this;
 }
 
 
 /*!
     \overload
 
     Reads a \c float \a f from the stream and returns a reference to
     the stream. See flags() for an explanation of the expected input
     format.
 */
 
 QTextStream &QTextStream::operator>>( float &f )
 {
     CHECK_STREAM_PRECOND
     f = (float)input_double();
     return *this;
 }
 
 
 /*!
     \overload
 
     Reads a \c double \a f from the stream and returns a reference to
     the stream. See flags() for an explanation of the expected input
     format.
 */
 
 QTextStream &QTextStream::operator>>( double &f )
 {
     CHECK_STREAM_PRECOND
     f = input_double();
     return *this;
 }
 
 
 /*!
     \overload
 
     Reads a "word" from the stream into \a s and returns a reference
     to the stream.
 
     A word consists of characters for which isspace() returns FALSE.
 */
 
 QTextStream &QTextStream::operator>>( char *s )
 {
     CHECK_STREAM_PRECOND
     int maxlen = width( 0 );
     QChar c = eat_ws();
     if ( !maxlen )
 	maxlen = -1;
     while ( c != QEOF ) {
 	if ( ts_isspace(c) || maxlen-- == 0 ) {
 	    ts_ungetc( c );
 	    break;
 	}
 	*s++ = c;
 	c = ts_getc();
     }
 
     *s = '\0';
     return *this;
 }
 
 /*!
     \overload
 
     Reads a "word" from the stream into \a str and returns a reference
     to the stream.
 
     A word consists of characters for which isspace() returns FALSE.
 */
 
 QTextStream &QTextStream::operator>>( QString &str )
 {
     CHECK_STREAM_PRECOND
     str=QString::fromLatin1("");
     QChar	c = eat_ws();
 
     while ( c != QEOF ) {
 	if ( ts_isspace(c) ) {
 	    ts_ungetc( c );
 	    break;
 	}
 	str += c;
 	c = ts_getc();
     }
     return *this;
 }
 
 /*!
     \overload
 
     Reads a "word" from the stream into \a str and returns a reference
     to the stream.
 
     A word consists of characters for which isspace() returns FALSE.
 */
 
 QTextStream &QTextStream::operator>>( QCString &str )
 {
     CHECK_STREAM_PRECOND
     QCString  *dynbuf = 0;
     const int buflen = 256;
     char      buffer[buflen];
     char     *s = buffer;
     int	      i = 0;
     QChar	      c = eat_ws();
 
     while ( c != QEOF ) {
 	if ( ts_isspace(c) ) {
 	    ts_ungetc( c );
 	    break;
 	}
 	if ( i >= buflen-1 ) {
 	    if ( !dynbuf )  {			// create dynamic buffer
 		dynbuf = new QCString(buflen*2);
 		memcpy( dynbuf->data(), s, i );	// copy old data
 	    } else if ( i >= (int)dynbuf->size()-1 ) {
 		dynbuf->resize( dynbuf->size()*2 );
 	    }
 	    s = dynbuf->data();
 	}
 	s[i++] = c;
 	c = ts_getc();
     }
     str.resize( i+1 );
     memcpy( str.data(), s, i );
     delete dynbuf;
     return *this;
 }
 
 
 /*!
     Reads a line from the stream and returns a string containing the
     text.
 
     The returned string does not contain any trailing newline or
     carriage return. Note that this is different from
     QIODevice::readLine(), which does not strip the newline at the end
     of the line.
 
     On EOF you will get a QString that is null. On reading an empty
     line the returned QString is empty but not null.
 
     \sa QIODevice::readLine()
 */
 
 QString QTextStream::readLine()
 {
 #if defined(QT_CHECK_STATE)
     if ( !dev ) {
 	qWarning( "QTextStream::readLine: No device" );
 	return QString::null;
     }
 #endif
     bool readCharByChar = TRUE;
     QString result;
 #if 0
     if ( !doUnicodeHeader && (
 	    (latin1) ||
 	    (mapper != 0 && mapper->mibEnum() == 106 ) // UTF 8
        ) ) {
 	readCharByChar = FALSE;
 	// use optimized read line
 	QChar c[getline_buf_size];
 	int pos = 0;
 	bool eof = FALSE;
 
 	for (;;) {
 	    pos = ts_getline( c );
 	    if ( pos == 0 ) {
 		// something went wrong; try fallback
 		readCharByChar = TRUE;
 		//dev->resetStatus();
 		break;
 	    }
 	    if ( c[pos-1] == QEOF || c[pos-1] == '\n' ) {
 		if ( pos>2 && c[pos-1]==QEOF && c[pos-2]=='\n' ) {
 		    result += QString( c, pos-2 );
 		} else if ( pos > 1 ) {
 		    result += QString( c, pos-1 );
 		}
 		if ( pos == 1 && c[pos-1] == QEOF )
 		    eof = TRUE;
 		break;
 	    } else {
 		result += QString( c, pos );
 	    }
 	}
 	if ( eof && result.isEmpty() )
 	    return QString::null;
     }
 #endif
     if ( readCharByChar ) {
 	// read character by character
 	const int buf_size = 256;
 	QChar c[buf_size];
 	int pos = 0;
 
 	c[pos] = ts_getc();
 	if ( c[pos] == QEOF ) {
 	    return QString::null;
 	}
 
 	while ( c[pos] != QEOF && c[pos] != '\n' ) {
 	    if ( c[pos] == '\r' ) { // ( handle mac and dos )
 		QChar nextc =  ts_getc();
 		if ( nextc != '\n' )
 		    ts_ungetc( nextc );
 		break;
 	    }
 	    pos++;
 	    if ( pos >= buf_size ) {
 		result += QString( c, pos );
 		pos = 0;
 	    }
 	    c[pos] = ts_getc();
 	}
 	result += QString( c, pos );
     }
 
     return result;
 }
 
 
 /*!
     Reads the entire stream and returns a string containing the text.
 
     \sa QIODevice::readLine()
 */
 
 QString QTextStream::read()
 {
 #if defined(QT_CHECK_STATE)
     if ( !dev ) {
 	qWarning( "QTextStream::read: No device" );
 	return QString::null;
     }
 #endif
     QString    result;
     const uint bufsize = 512;
     QChar      buf[bufsize];
     uint       i, num, start;
     bool       skipped_cr = FALSE;
 
     for (;;) {
 	num = ts_getbuf(buf,bufsize);
 	// convert dos (\r\n) and mac (\r) style eol to unix style (\n)
 	start = 0;
 	for ( i=0; i<num; i++ ) {
 	    if ( buf[i] == '\r' ) {
 		// Only skip single cr's preceding lf's
 		if ( skipped_cr ) {
 		    result += buf[i];
 		    start++;
 		} else {
 		    result += QString( &buf[start], i-start );
 		    start = i+1;
 		    skipped_cr = TRUE;
 		}
 	    } else {
 		if ( skipped_cr ) {
 		    if ( buf[i] != '\n' ) {
 			// Should not have skipped it
 			result += '\n';
 		    }
 		    skipped_cr = FALSE;
 		}
 	    }
 	}
 	if ( start < num )
 	    result += QString( &buf[start], i-start );
 	if ( num != bufsize ) // if ( EOF )
 	    break;
     }
     return result;
 }
 
 
 
 /*****************************************************************************
   QTextStream write functions
  *****************************************************************************/
 
 /*!
     Writes character \c char to the stream and returns a reference to
     the stream.
 
     The character \a c is assumed to be Latin1 encoded independent of
     the Encoding set for the QTextStream.
 */
 QTextStream &QTextStream::operator<<( QChar c )
 {
     CHECK_STREAM_PRECOND
     ts_putc( c );
     return *this;
 }
 
 /*!
     \overload
 
     Writes character \a c to the stream and returns a reference to the
     stream.
 */
 QTextStream &QTextStream::operator<<( char c )
 {
     CHECK_STREAM_PRECOND
     unsigned char uc = (unsigned char) c;
     ts_putc( uc );
     return *this;
 }
 
 QTextStream &QTextStream::output_int( int format, ulong n, bool neg )
 {
     static const char hexdigits_lower[] = "0123456789abcdef";
     static const char hexdigits_upper[] = "0123456789ABCDEF";
     CHECK_STREAM_PRECOND
     char buf[76];
     register char *p;
     int	  len;
     const char *hexdigits;
 
     switch ( flags() & I_BASE_MASK ) {
 
 	case I_BASE_2:				// output binary number
 	    switch ( format & I_TYPE_MASK ) {
 		case I_SHORT: len=16; break;
 		case I_INT:   len=sizeof(int)*8; break;
 		case I_LONG:  len=32; break;
 		default:      len = 0;
 	    }
 	    p = &buf[74];			// go reverse order
 	    *p = '\0';
 	    while ( len-- ) {
 		*--p = (char)(n&1) + '0';
 		n >>= 1;
 		if ( !n )
 		    break;
 	    }
 	    if ( flags() & showbase ) {		// show base
 		*--p = (flags() & uppercase) ? 'B' : 'b';
 		*--p = '0';
 	    }
 	    break;
 
 	case I_BASE_8:				// output octal number
 	    p = &buf[74];
 	    *p = '\0';
 	    do {
 		*--p = (char)(n&7) + '0';
 		n >>= 3;
 	    } while ( n );
 	    if ( flags() & showbase )
 		*--p = '0';
 	    break;
 
 	case I_BASE_16:				// output hexadecimal number
 	    p = &buf[74];
 	    *p = '\0';
 	    hexdigits = (flags() & uppercase) ?
 		hexdigits_upper : hexdigits_lower;
 	    do {
 		*--p = hexdigits[(int)n&0xf];
 		n >>= 4;
 	    } while ( n );
 	    if ( flags() & showbase ) {
 		*--p = (flags() & uppercase) ? 'X' : 'x';
 		*--p = '0';
 	    }
 	    break;
 
 	default:				// decimal base is default
 	    p = &buf[74];
 	    *p = '\0';
 	    if ( neg )
 		n = (ulong)(-(long)n);
 	    do {
 		*--p = ((int)(n%10)) + '0';
 		n /= 10;
 	    } while ( n );
 	    if ( neg )
 		*--p = '-';
 	    else if ( flags() & showpos )
 		*--p = '+';
 	    if ( (flags() & internal) && fwidth && !ts_isdigit(*p) ) {
 		ts_putc( *p );			// special case for internal
 		++p;				//   padding
 		fwidth--;
 		return *this << (const char*)p;
 	    }
     }
     if ( fwidth ) {				// adjustment required
 	if ( !(flags() & left) ) {		// but NOT left adjustment
 	    len = qstrlen(p);
 	    int padlen = fwidth - len;
 	    if ( padlen <= 0 ) {		// no padding required
 		writeBlock( p, len );
 	    } else if ( padlen < (int)(p-buf) ) { // speeds up padding
 		memset( p-padlen, (char)fillchar, padlen );
 		writeBlock( p-padlen, padlen+len );
 	    }
 	    else				// standard padding
 		*this << (const char*)p;
 	}
 	else
 	    *this << (const char*)p;
 	fwidth = 0;				// reset field width
     }
     else
 	writeBlock( p, qstrlen(p) );
     return *this;
 }
 
 
 /*!
     \overload
 
     Writes a \c short integer \a i to the stream and returns a
     reference to the stream.
 */
 
 QTextStream &QTextStream::operator<<( signed short i )
 {
     return output_int( I_SHORT | I_SIGNED, i, i < 0 );
 }
 
 
 /*!
     \overload
 
     Writes an \c unsigned \c short integer \a i to the stream and
     returns a reference to the stream.
 */
 
 QTextStream &QTextStream::operator<<( unsigned short i )
 {
     return output_int( I_SHORT | I_UNSIGNED, i, FALSE );
 }
 
 
 /*!
     \overload
 
     Writes an \c int \a i to the stream and returns a reference to the
     stream.
 */
 
 QTextStream &QTextStream::operator<<( signed int i )
 {
     return output_int( I_INT | I_SIGNED, i, i < 0 );
 }
 
 
 /*!
     \overload
 
     Writes an \c unsigned \c int \a i to the stream and returns a
     reference to the stream.
 */
 
 QTextStream &QTextStream::operator<<( unsigned int i )
 {
     return output_int( I_INT | I_UNSIGNED, i, FALSE );
 }
 
 
 /*!
     \overload
 
     Writes a \c long \c int \a i to the stream and returns a reference
     to the stream.
 */
 
 QTextStream &QTextStream::operator<<( signed long i )
 {
     return output_int( I_LONG | I_SIGNED, i, i < 0 );
 }
 
 
 /*!
     \overload
 
     Writes an \c unsigned \c long \c int \a i to the stream and
     returns a reference to the stream.
 */
 
 QTextStream &QTextStream::operator<<( unsigned long i )
 {
     return output_int( I_LONG | I_UNSIGNED, i, FALSE );
 }
 
 
 /*!
     \overload
 
     Writes a \c float \a f to the stream and returns a reference to
     the stream.
 */
 
 QTextStream &QTextStream::operator<<( float f )
 {
     return *this << (double)f;
 }
 
 
 /*!
     \overload
 
     Writes a \c double \a f to the stream and returns a reference to
     the stream.
 */
 
 QTextStream &QTextStream::operator<<( double f )
 {
     CHECK_STREAM_PRECOND
     char buf[64];
     char f_char;
     char format[16];
     if ( (flags()&floatfield) == fixed )
 	f_char = 'f';
     else if ( (flags()&floatfield) == scientific )
 	f_char = (flags() & uppercase) ? 'E' : 'e';
     else
 	f_char = (flags() & uppercase) ? 'G' : 'g';
     register char *fs = format;			// generate format string
     *fs++ = '%';				//   "%.<prec>l<f_char>"
     *fs++ = '.';
     int prec = precision();
     if ( prec > 99 )
 	prec = 99;
     if ( prec >= 10 ) {
 	*fs++ = prec / 10 + '0';
 	*fs++ = prec % 10 + '0';
     } else {
 	*fs++ = prec + '0';
     }
     *fs++ = 'l';
     *fs++ = f_char;
     *fs = '\0';
     sprintf( buf, format, f );			// convert to text
     if ( fwidth )				// padding
 	*this << (const char*)buf;
     else					// just write it
 	writeBlock( buf, qstrlen(buf) );
     return *this;
 }
 
 
 /*!
     \overload
 
     Writes a string to the stream and returns a reference to the
     stream.
 
     The string \a s is assumed to be Latin1 encoded independent of the
     Encoding set for the QTextStream.
 */
 
 QTextStream &QTextStream::operator<<( const char* s )
 {
     CHECK_STREAM_PRECOND
     char padbuf[48];
     uint len = qstrlen( s );			// don't write null terminator
     if ( fwidth ) {				// field width set
 	int padlen = fwidth - len;
 	fwidth = 0;				// reset width
 	if ( padlen > 0 ) {
 	    char *ppad;
 	    if ( padlen > 46 ) {		// create extra big fill buffer
 		ppad = new char[padlen];
 		Q_CHECK_PTR( ppad );
 	    } else {
 		ppad = padbuf;
 	    }
 	    memset( ppad, (char)fillchar, padlen );	// fill with fillchar
 	    if ( !(flags() & left) ) {
 		writeBlock( ppad, padlen );
 		padlen = 0;
 	    }
 	    writeBlock( s, len );
 	    if ( padlen )
 		writeBlock( ppad, padlen );
 	    if ( ppad != padbuf )		// delete extra big fill buf
 		delete[] ppad;
 	    return *this;
 	}
     }
     writeBlock( s, len );
     return *this;
 }
 
 /*!
     \overload
 
     Writes \a s to the stream and returns a reference to the stream.
 
     The string \a s is assumed to be Latin1 encoded independent of the
     Encoding set for the QTextStream.
 */
 
 QTextStream &QTextStream::operator<<( const QCString & s )
 {
     return operator<<(s.data());
 }
 
 /*!
     \overload
 
     Writes \a s to the stream and returns a reference to the stream.
 */
 
 QTextStream &QTextStream::operator<<( const QString& s )
 {
     if ( !mapper && latin1 )
 	return operator<<(s.latin1());
     CHECK_STREAM_PRECOND
     QString s1 = s;
     if ( fwidth ) {				// field width set
 	if ( !(flags() & left) ) {
 	    s1 = s.rightJustify(fwidth, (char)fillchar);
 	} else {
 	    s1 = s.leftJustify(fwidth, (char)fillchar);
 	}
 	fwidth = 0;				// reset width
     }
     writeBlock( s1.unicode(), s1.length() );
     return *this;
 }
 
 
 /*!
     \overload
 
     Writes a pointer to the stream and returns a reference to the
     stream.
 
     The \a ptr is output as an unsigned long hexadecimal integer.
 */
 
 QTextStream &QTextStream::operator<<( void *ptr )
 {
     int f = flags();
     setf( hex, basefield );
     setf( showbase );
     unsetf( uppercase );
     output_int( I_LONG | I_UNSIGNED, (ulong)ptr, FALSE );
     flags( f );
     return *this;
 }
 
 
 /*!
     \fn int QTextStream::flags() const
 
     Returns the current stream flags. The default value is 0.
 
     \table
     \header \i Flag \i Meaning
     \row \i \c skipws \i Not currently used; whitespace always skipped
     \row \i \c left \i Numeric fields are left-aligned
     \row \i \c right
 	 \i Not currently used (by default, numerics are right-aligned)
     \row \i \c internal \i Puts any padding spaces between +/- and value
     \row \i \c bin \i Output \e and input only in binary
     \row \i \c oct \i Output \e and input only in octal
     \row \i \c dec \i Output \e and input only in decimal
     \row \i \c hex \i Output \e and input only in hexadecimal
     \row \i \c showbase
 	 \i Annotates numeric outputs with 0b, 0, or 0x if in \c bin,
 	 \c oct, or \c hex format
     \row \i \c showpoint \i Not currently used
     \row \i \c uppercase \i Uses 0B and 0X rather than 0b and 0x
     \row \i \c showpos \i Shows + for positive numeric values
     \row \i \c scientific \i Uses scientific notation for floating point values
     \row \i \c fixed \i Uses fixed-point notation for floating point values
     \endtable
 
     Note that unless \c bin, \c oct, \c dec, or \c hex is set, the
     input base is octal if the value starts with 0, hexadecimal if it
     starts with 0x, binary if it starts with 0b, and decimal
     otherwise.
 
     \sa setf(), unsetf()
 */
 
 /*!
     \fn int QTextStream::flags( int f )
 
     \overload
 
     Sets the stream flags to \a f. Returns the previous stream flags.
 
     \sa setf(), unsetf(), flags()
 */
 
 /*!
     \fn int QTextStream::setf( int bits )
 
     Sets the stream flag bits \a bits. Returns the previous stream
     flags.
 
     Equivalent to \c{flags( flags() | bits )}.
 
     \sa setf(), unsetf()
 */
 
 /*!
     \fn int QTextStream::setf( int bits, int mask )
 
     \overload
 
     Sets the stream flag bits \a bits with a bit mask \a mask. Returns
     the previous stream flags.
 
     Equivalent to \c{flags( (flags() & ~mask) | (bits & mask) )}.
 
     \sa setf(), unsetf()
 */
 
 /*!
     \fn int QTextStream::unsetf( int bits )
 
     Clears the stream flag bits \a bits. Returns the previous stream
     flags.
 
     Equivalent to \c{flags( flags() & ~mask )}.
 
     \sa setf()
 */
 
 /*!
     \fn int QTextStream::width() const
 
     Returns the field width. The default value is 0.
 */
 
 /*!
     \fn int QTextStream::width( int w )
 
     \overload
 
     Sets the field width to \a w. Returns the previous field width.
 */
 
 /*!
     \fn int QTextStream::fill() const
 
     Returns the fill character. The default value is ' ' (space).
 */
 
 /*!
     \overload int QTextStream::fill( int f )
 
     Sets the fill character to \a f. Returns the previous fill character.
 */
 
 /*!
     \fn int QTextStream::precision() const
 
     Returns the precision. The default value is 6.
 */
 
 /*!
     \fn int QTextStream::precision( int p )
 
     \overload
 
     Sets the precision to \a p. Returns the previous precision setting.
 */
 
 
  /*****************************************************************************
   QTextStream manipulators
  *****************************************************************************/
 
 QTextStream &bin( QTextStream &s )
 {
     s.setf(QTS::bin,QTS::basefield);
     return s;
 }
 
 QTextStream &oct( QTextStream &s )
 {
     s.setf(QTS::oct,QTS::basefield);
     return s;
 }
 
 QTextStream &dec( QTextStream &s )
 {
     s.setf(QTS::dec,QTS::basefield);
     return s;
 }
 
 QTextStream &hex( QTextStream &s )
 {
     s.setf(QTS::hex,QTS::basefield);
     return s;
 }
 
 QTextStream &endl( QTextStream &s )
 {
     return s << '\n';
 }
 
 QTextStream &flush( QTextStream &s )
 {
     if ( s.device() )
 	s.device()->flush();
     return s;
 }
 
 QTextStream &ws( QTextStream &s )
 {
     s.skipWhiteSpace();
     return s;
 }
 
 QTextStream &reset( QTextStream &s )
 {
     s.reset();
     return s;
 }
 
 
 /*!
     \class QTextIStream qtextstream.h
     \reentrant
     \brief The QTextIStream class is a convenience class for input streams.
 
     \ingroup io
     \ingroup text
 
     This class provides a shorthand for creating simple input
     \l{QTextStream}s without having to pass a \e mode argument to the
     constructor.
 
     This class makes it easy, for example, to write things like this:
     \code
     QString data = "123 456";
     int a, b;
     QTextIStream(&data) >> a >> b;
     \endcode
 
     \sa QTextOStream
 */
 
 /*!
     \fn QTextIStream::QTextIStream( const QString *s )
 
     Constructs a stream to read from the string \a s.
 */
 /*!
     \fn QTextIStream::QTextIStream( QByteArray ba )
 
     Constructs a stream to read from the array \a ba.
 */
 /*!
     \fn QTextIStream::QTextIStream( FILE *f )
 
     Constructs a stream to read from the file \a f.
 */
 
 
 /*!
     \class QTextOStream
     \reentrant
     \brief The QTextOStream class is a convenience class for output streams.
 
     \ingroup io
     \ingroup text
 
     This class provides a shorthand for creating simple output
     \l{QTextStream}s without having to pass a \e mode argument to the
     constructor.
 
     This makes it easy for example, to write things like this:
     \code
     QString result;
     QTextOStream(&result) << "pi = " << 3.14;
     \endcode
 */
 
 /*!
     \fn QTextOStream::QTextOStream( QString *s )
 
     Constructs a stream to write to string \a s.
 */
 /*!
     \fn QTextOStream::QTextOStream( QByteArray ba )
 
     Constructs a stream to write to the array \a ba.
 */
 /*!
     \fn QTextOStream::QTextOStream( FILE *f )
 
     Constructs a stream to write to the file \a f.
 */
 
 
 
 /*!
   Sets the encoding of this stream to \a e, where \a e is one of the
   following values:
   \table
   \header \i Encoding \i Meaning
   \row \i Locale
        \i Uses local file format (Latin1 if locale is not set), but
        autodetecting Unicode(utf16) on input.
   \row \i Unicode
        \i Uses Unicode(utf16) for input and output. Output will be
        written in the order most efficient for the current platform
        (i.e. the order used internally in QString).
   \row \i UnicodeUTF8
        \i Using Unicode(utf8) for input and output. If you use it for
        input it will autodetect utf16 and use it instead of utf8.
   \row \i Latin1
        \i ISO-8859-1. Will not autodetect utf16.
   \row \i UnicodeNetworkOrder
        \i Uses network order Unicode(utf16) for input and output.
        Useful when reading Unicode data that does not start with the
        byte order marker.
   \row \i UnicodeReverse
        \i Uses reverse network order Unicode(utf16) for input and
        output. Useful when reading Unicode data that does not start
        with the byte order marker or when writing data that should be
        read by buggy Windows applications.
   \row \i RawUnicode
        \i Like Unicode, but does not write the byte order marker nor
        does it auto-detect the byte order. Useful only when writing to
        non-persistent storage used by a single process.
   \endtable
 
   \c Locale and all Unicode encodings, except \c RawUnicode, will look
   at the first two bytes in an input stream to determine the byte
   order. The initial byte order marker will be stripped off before
   data is read.
 
   Note that this function should be called before any data is read to
   or written from the stream.
 
   \sa setCodec()
 */
 
 void QTextStream::setEncoding( Encoding e )
 {
     if ( d->sourceType == QTextStreamPrivate::String )
 	return;
 
     switch ( e ) {
     case Unicode:
 	mapper = 0;
 	latin1 = FALSE;
 	doUnicodeHeader = TRUE;
 	internalOrder = TRUE;
 	networkOrder = QChar::networkOrdered();
 	break;
     case UnicodeUTF8:
 #ifndef QT_NO_TEXTCODEC
 	mapper = QTextCodec::codecForMib( 106 );
 	latin1 = FALSE;
 	doUnicodeHeader = TRUE;
 	internalOrder = TRUE;
 	networkOrder = QChar::networkOrdered();
 #else
 	mapper = 0;
 	latin1 = TRUE;
 	doUnicodeHeader = TRUE;
 #endif
 	break;
     case UnicodeNetworkOrder:
 	mapper = 0;
 	latin1 = FALSE;
 	doUnicodeHeader = TRUE;
 	internalOrder = QChar::networkOrdered();
 	networkOrder = TRUE;
 	break;
     case UnicodeReverse:
 	mapper = 0;
 	latin1 = FALSE;
 	doUnicodeHeader = TRUE;
 	internalOrder = !QChar::networkOrdered();
 	networkOrder = FALSE;
 	break;
     case RawUnicode:
 	mapper = 0;
 	latin1 = FALSE;
 	doUnicodeHeader = FALSE;
 	internalOrder = TRUE;
 	networkOrder = QChar::networkOrdered();
 	break;
     case Locale:
 	latin1 = TRUE; // fallback to Latin-1
 #ifndef QT_NO_TEXTCODEC
 	mapper = QTextCodec::codecForLocale();
 	// optimized Latin-1 processing
 #if defined(Q_OS_WIN32)
 	if ( GetACP() == 1252 )
 	    mapper = 0;
 #endif
 	if ( mapper && mapper->mibEnum() == 4 )
 #endif
 	    mapper = 0;
 
 	doUnicodeHeader = TRUE; // If it reads as Unicode, accept it
 	break;
     case Latin1:
 	mapper = 0;
 	doUnicodeHeader = FALSE;
 	latin1 = TRUE;
 	break;
     }
 }
 
 
 #ifndef QT_NO_TEXTCODEC
 /*!
     Sets the codec for this stream to \a codec. Will not try to
     autodetect Unicode.
 
     Note that this function should be called before any data is read
     to/written from the stream.
 
     \sa setEncoding(), codec()
 */
 
 void QTextStream::setCodec( QTextCodec *codec )
 {
     if ( d->sourceType == QTextStreamPrivate::String )
 	return; // QString does not need any codec
     mapper = codec;
     latin1 = ( codec->mibEnum() == 4 );
     if ( latin1 )
 	mapper = 0;
     doUnicodeHeader = FALSE;
 }
 
 /*!
   Returns the codec actually used for this stream.
 
   If Unicode is automatically detected in input, a codec with \link
   QTextCodec::name() name() \endlink "ISO-10646-UCS-2" is returned.
 
   \sa setCodec()
 */
 
 QTextCodec *QTextStream::codec()
 {
     if ( mapper ) {
 	return mapper;
     } else {
 	// 4 is "ISO 8859-1", 1000 is "ISO-10646-UCS-2"
 	return QTextCodec::codecForMib( latin1 ? 4 : 1000 );
     }
 }
 
 #endif
 
 #endif // QT_NO_TEXTSTREAM
diff --git a/qmake/tools/qucom.cpp b/qmake/tools/qucom.cpp
index 6086a79..658da97 100644
--- a/qmake/tools/qucom.cpp
+++ b/qmake/tools/qucom.cpp
@@ -1,668 +1,544 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of the QUcom classes
 **
 ** Created : 990101
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qucom_p.h"
 
 // Standard types
 
 // {DE56510E-4E9F-4b76-A3C2-D1E2EF42F1AC}
 const QUuid TID_QUType_Null( 0xde56510e, 0x4e9f, 0x4b76, 0xa3, 0xc2, 0xd1, 0xe2, 0xef, 0x42, 0xf1, 0xac );
 const QUuid *QUType_Null::uuid() const { return &TID_QUType_Null; }
 const char *QUType_Null::desc() const { return "null"; }
 bool QUType_Null::canConvertFrom( QUObject *, QUType * ) { return FALSE; }
 bool QUType_Null::canConvertTo( QUObject *, QUType * ) { return FALSE; }
 bool QUType_Null::convertFrom( QUObject *, QUType * ) { return FALSE; }
 bool QUType_Null::convertTo( QUObject *, QUType * ) { return FALSE; }
 void QUType_Null::clear( QUObject *) {};
 int QUType_Null::serializeTo( QUObject *, QUBuffer * ) { return 0; }
 int QUType_Null::serializeFrom( QUObject *, QUBuffer * ) { return 0; };
 QUType_Null static_QUType_Null;
 
 
 // {7EE17B08-5419-47e2-9776-8EEA112DCAEC}
 const QUuid TID_QUType_enum( 0x7ee17b08, 0x5419, 0x47e2, 0x97, 0x76, 0x8e, 0xea, 0x11, 0x2d, 0xca, 0xec );
 QUType_enum static_QUType_enum;
 const QUuid *QUType_enum::uuid() const { return &TID_QUType_enum; }
 const char *QUType_enum::desc() const { return "enum"; }
 void QUType_enum::set( QUObject *o, int v )
 {
     o->payload.i = v;
     o->type = this;
 }
 
 bool QUType_enum::canConvertFrom( QUObject *o, QUType *t )
 {
     if ( isEqual( t, &static_QUType_int ) ) // ## todo unsigned int?
 	return TRUE;
 
     return t->canConvertTo( o, this );
 }
 
 bool QUType_enum::canConvertTo( QUObject * /*o*/, QUType *t )
 {
     return isEqual( t, &static_QUType_int );
 }
 
 bool QUType_enum::convertFrom( QUObject *o, QUType *t )
 {
     if ( isEqual( t, &static_QUType_int ) ) // ## todo unsigned int?
 	;
     else
 	return t->convertTo( o, this );
 
     o->type = this;
     return TRUE;
 }
 
 bool QUType_enum::convertTo( QUObject *o, QUType *t )
 {
     if ( isEqual( t,  &static_QUType_int ) ) {
 	o->type = &static_QUType_int;
 	return TRUE;
     }
     return FALSE;
 }
 
 int QUType_enum::serializeTo( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 int QUType_enum::serializeFrom( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 // {8AC26448-5AB4-49eb-968C-8F30AB13D732}
 const QUuid TID_QUType_ptr( 0x8ac26448, 0x5ab4, 0x49eb, 0x96, 0x8c, 0x8f, 0x30, 0xab, 0x13, 0xd7, 0x32 );
 QUType_ptr static_QUType_ptr;
 const QUuid *QUType_ptr::uuid() const  { return &TID_QUType_ptr; }
 const char *QUType_ptr::desc() const { return "ptr"; }
 
 void QUType_ptr::set( QUObject *o, const void* v )
 {
     o->payload.ptr = (void*) v;
     o->type = this;
 }
 
 bool QUType_ptr::canConvertFrom( QUObject *o, QUType *t )
 {
     return t->canConvertTo( o, this );
 }
 
 bool QUType_ptr::canConvertTo( QUObject *, QUType * )
 {
     return FALSE;
 }
 
 bool QUType_ptr::convertFrom( QUObject *o, QUType *t )
 {
     return t->convertTo( o, this );
 }
 
 bool QUType_ptr::convertTo( QUObject *, QUType * )
 {
     return FALSE;
 }
 
 int QUType_ptr::serializeTo( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 int QUType_ptr::serializeFrom( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 // {97A2594D-6496-4402-A11E-55AEF2D4D25C}
 const QUuid TID_QUType_iface( 0x97a2594d, 0x6496, 0x4402, 0xa1, 0x1e, 0x55, 0xae, 0xf2, 0xd4, 0xd2, 0x5c );
 QUType_iface static_QUType_iface;
 const QUuid *QUType_iface::uuid() const  { return &TID_QUType_iface; }
 const char *QUType_iface::desc() const { return "UnknownInterface"; }
 
 void QUType_iface::set( QUObject *o, QUnknownInterface* iface )
 {
     o->payload.iface = iface;
     o->type = this;
 }
 
 bool QUType_iface::canConvertFrom( QUObject *o, QUType *t )
 {
     return t->canConvertTo( o, this );
 }
 
 bool QUType_iface::canConvertTo( QUObject *, QUType * )
 {
     return FALSE;
 }
 
 bool QUType_iface::convertFrom( QUObject *o, QUType *t )
 {
     return t->convertTo( o, this );
 }
 
 bool QUType_iface::convertTo( QUObject *, QUType * )
 {
     return FALSE;
 }
 
 int QUType_iface::serializeTo( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 int QUType_iface::serializeFrom( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 // {2F358164-E28F-4bf4-9FA9-4E0CDCABA50B}
 const QUuid TID_QUType_idisp( 0x2f358164, 0xe28f, 0x4bf4, 0x9f, 0xa9, 0x4e, 0xc, 0xdc, 0xab, 0xa5, 0xb );
 QUType_idisp static_QUType_idisp;
 const QUuid *QUType_idisp::uuid() const  { return &TID_QUType_idisp; }
 const char *QUType_idisp::desc() const { return "DispatchInterface"; }
 
 void QUType_idisp::set( QUObject *o, QDispatchInterface* idisp )
 {
     o->payload.idisp = idisp;
     o->type = this;
 }
 
 bool QUType_idisp::canConvertFrom( QUObject *o, QUType *t )
 {
     return t->canConvertTo( o, this );
 }
 
 bool QUType_idisp::canConvertTo( QUObject * /*o*/, QUType *t )
 {
     return isEqual( t, &static_QUType_iface );
 }
 
 bool QUType_idisp::convertFrom( QUObject *o, QUType *t )
 {
     return t->convertTo( o, this );
 }
 
 bool QUType_idisp::convertTo( QUObject *o, QUType *t )
 {
 #ifndef QT_NO_COMPONENT
     if ( isEqual( t, &static_QUType_iface ) ) {
 	o->payload.iface = (QUnknownInterface*)o->payload.idisp;
 	o->type = &static_QUType_iface;
 	return TRUE;
     }
 #endif
     return FALSE;
 }
 
 int QUType_idisp::serializeTo( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 int QUType_idisp::serializeFrom( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 // {CA42115D-13D0-456c-82B5-FC10187F313E}
 const QUuid TID_QUType_bool( 0xca42115d, 0x13d0, 0x456c, 0x82, 0xb5, 0xfc, 0x10, 0x18, 0x7f, 0x31, 0x3e );
 QUType_bool static_QUType_bool;
 const QUuid *QUType_bool::uuid() const  { return &TID_QUType_bool; }
 const char *QUType_bool::desc() const { return "bool"; }
 
 void QUType_bool::set( QUObject *o, bool v )
 {
     o->payload.b = v;
     o->type = this;
 }
 
 bool QUType_bool::canConvertFrom( QUObject *o, QUType *t )
 {
     return t->canConvertTo( o, this );
 }
 
 bool QUType_bool::canConvertTo( QUObject *, QUType * )
 {
     return FALSE;
 }
 
 bool QUType_bool::convertFrom( QUObject *o, QUType *t )
 {
     return t->convertTo( o, this );
 }
 
 bool QUType_bool::convertTo( QUObject *, QUType * )
 {
     return FALSE;
 }
 
 int QUType_bool::serializeTo( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 int QUType_bool::serializeFrom( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 // {53C1F3BE-73C3-4c7d-9E05-CCF09EB676B5}
 const QUuid TID_QUType_int( 0x53c1f3be, 0x73c3, 0x4c7d, 0x9e, 0x5, 0xcc, 0xf0, 0x9e, 0xb6, 0x76, 0xb5 );
 QUType_int static_QUType_int;
 const QUuid *QUType_int::uuid() const  { return &TID_QUType_int; }
 const char *QUType_int::desc() const { return "int"; }
 
 void QUType_int::set( QUObject *o, int v )
 {
     o->payload.i = v;
     o->type = this;
 }
 
 bool QUType_int::canConvertFrom( QUObject *o, QUType *t )
 {
-    if ( isEqual( t, &static_QUType_double ) ||
-	 isEqual( t, &static_QUType_float ) )
+    if ( isEqual( t, &static_QUType_double ) )
 	return TRUE;
 
     return t->canConvertTo( o, this );
 }
 
 bool QUType_int::canConvertTo( QUObject * /*o*/, QUType *t )
 {
-    return isEqual( t,  &static_QUType_double ) ||
-	isEqual( t, &static_QUType_float );
+    return isEqual( t,  &static_QUType_double );
 }
 
 bool QUType_int::convertFrom( QUObject *o, QUType *t )
 {
     if ( isEqual( t, &static_QUType_double ) )
 	o->payload.i = (long)o->payload.d;
-    else if ( isEqual( t, &static_QUType_float ) )
-	o->payload.i = (long)o->payload.f;
     else
 	return t->convertTo( o, this );
 
     o->type = this;
     return TRUE;
 }
 
 bool QUType_int::convertTo( QUObject *o, QUType *t )
 {
     if ( isEqual( t,  &static_QUType_double ) ) {
 	o->payload.d = (double)o->payload.i;
 	o->type = &static_QUType_double;
-    } else if ( isEqual( t,  &static_QUType_float ) ) {	
-	o->payload.f = (float)o->payload.i;
-	o->type = &static_QUType_float;
     } else
 	return FALSE;
     return TRUE;
 }
 
 int QUType_int::serializeTo( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 int QUType_int::serializeFrom( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
-// {5938712A-C496-11D5-8CB2-00C0F03BC0F3}
-const QUuid TID_QUType_uint( 0x5938712a, 0xc496, 0x11d5, 0x8c, 0xb2, 0x00, 0xc0, 0xf0, 0x3b, 0xc0, 0xf3);
-QUType_uint static_QUType_uint;
-const QUuid *QUType_uint::uuid() const  { return &TID_QUType_uint; }
-const char *QUType_uint::desc() const { return "uint"; }
-
-void QUType_uint::set( QUObject *o, uint v )
-{
-    o->payload.ui = v;
-    o->type = this;
-}
-
-bool QUType_uint::canConvertFrom( QUObject *o, QUType *t )
-{
-    return t->canConvertTo( o, this );
-}
-
-bool QUType_uint::canConvertTo( QUObject * /*o*/, QUType * /*t*/ )
-{
-    return FALSE;
-}
-
-bool QUType_uint::convertFrom( QUObject *o, QUType *t )
-{
-    return t->convertTo( o, this );
-}
-
-bool QUType_uint::convertTo( QUObject * /*o*/, QUType * /*t*/ )
-{
-    return FALSE;
-}
-
-int QUType_uint::serializeTo( QUObject *, QUBuffer * )
-{
-    return 0;
-}
-
-int QUType_uint::serializeFrom( QUObject *, QUBuffer * )
-{
-    return 0;
-}
-
 // {2D0974E5-0BA6-4ec2-8837-C198972CB48C}
 const QUuid TID_QUType_double( 0x2d0974e5, 0xba6, 0x4ec2, 0x88, 0x37, 0xc1, 0x98, 0x97, 0x2c, 0xb4, 0x8c );
 QUType_double static_QUType_double;
 const QUuid *QUType_double::uuid() const { return &TID_QUType_double; }
 const char *QUType_double::desc() const {return "double"; }
 
 void QUType_double::set( QUObject *o, double v )
 {
     o->payload.d = v;
     o->type = this;
 }
 
 bool QUType_double::canConvertFrom( QUObject *o, QUType *t )
 {
-    if ( isEqual( t, &static_QUType_int ) ||
-	 isEqual( t, &static_QUType_float) )
+    if ( isEqual( t, &static_QUType_int ) )
 	return TRUE;
 
     return t->canConvertTo( o, this );
 }
 
 bool QUType_double::canConvertTo( QUObject * /*o*/, QUType *t )
 {
-    return isEqual( t,  &static_QUType_int ) ||
-	isEqual( t,  &static_QUType_float );
+    return isEqual( t,  &static_QUType_int );
 }
 
 bool QUType_double::convertFrom( QUObject *o, QUType *t )
 {
     if ( isEqual( t, &static_QUType_int ) )
 	o->payload.d = (double)o->payload.i;
-    else if ( isEqual( t, &static_QUType_float ) )
-	o->payload.d = (double)o->payload.f;
-    else
+     else
 	return t->convertTo( o, this );
 
     o->type = this;
     return TRUE;
 }
 
 bool QUType_double::convertTo( QUObject *o, QUType *t )
 {
     if ( isEqual( t,  &static_QUType_int ) ) {
 	o->payload.i = (int) o->payload.d;
 	o->type = &static_QUType_int;
     } else if ( isEqual( t,  &static_QUType_double ) ) {
 	o->payload.d = (double) o->payload.f;
 	o->type = &static_QUType_double;
     } else
 	return FALSE;
     return TRUE;
 }
 
 int QUType_double::serializeTo( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 int QUType_double::serializeFrom( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
-
-// {544C5175-6993-4486-B04D-CEC4D21BF4B9 }
-const QUuid TID_QUType_float( 0x544c5175, 0x6993, 0x4486, 0xb0, 0x4d, 0xce, 0xc4, 0xd2, 0x1b, 0xf4, 0xb9 );
-QUType_float static_QUType_float;
-const QUuid *QUType_float::uuid() const { return &TID_QUType_float; }
-const char *QUType_float::desc() const {return "float"; }
-
-void QUType_float::set( QUObject *o, float v )
-{
-    o->payload.f = v;
-    o->type = this;
-}
-
-bool QUType_float::canConvertFrom( QUObject *o, QUType *t )
-{
-    if ( isEqual( t, &static_QUType_int ) ||
-	 isEqual( t, &static_QUType_double ) )
-	return TRUE;
-
-    return t->canConvertTo( o, this );
-}
-
-bool QUType_float::canConvertTo( QUObject * /*o*/, QUType *t )
-{
-    return isEqual( t,  &static_QUType_int ) ||
-	isEqual( t,  &static_QUType_double );
-}
-
-bool QUType_float::convertFrom( QUObject *o, QUType *t )
-{
-    if ( isEqual( t, &static_QUType_int ) )
-	o->payload.f = (float)o->payload.i;
-    else if ( isEqual( t, &static_QUType_double ) )
-	o->payload.f = (float)o->payload.d;
-    else
-	return t->convertTo( o, this );
-
-    o->type = this;
-    return TRUE;
-}
-
-bool QUType_float::convertTo( QUObject *o, QUType *t )
-{
-    if ( isEqual( t,  &static_QUType_int ) ) {
-	o->payload.i = (int) o->payload.f;
-	o->type = &static_QUType_int;
-    } else if ( isEqual( t,  &static_QUType_double ) ) {
-	o->payload.d = (double) o->payload.f;
-	o->type = &static_QUType_double;
-    } else
-	return FALSE;
-    return TRUE;
-}
-
-int QUType_float::serializeTo( QUObject *, QUBuffer * )
-{
-    return 0;
-}
-
-int QUType_float::serializeFrom( QUObject *, QUBuffer * )
-{
-    return 0;
-}
-
 // {EFCDD1D4-77A3-4b8e-8D46-DC14B8D393E9}
 const QUuid TID_QUType_charstar( 0xefcdd1d4, 0x77a3, 0x4b8e, 0x8d, 0x46, 0xdc, 0x14, 0xb8, 0xd3, 0x93, 0xe9 );
 QUType_charstar static_QUType_charstar;
 const QUuid *QUType_charstar::uuid() const { return &TID_QUType_charstar; }
 const char *QUType_charstar::desc() const { return "char*"; }
 
 void QUType_charstar::set( QUObject *o, const char* v, bool take )
 {
     if ( take ) {
 	if ( v ) {
 	    o->payload.charstar.ptr = new char[ strlen(v) + 1 ];
 	    strcpy( o->payload.charstar.ptr, v );
 	} else {
 	    o->payload.charstar.ptr = 0;
 	}
 	o->payload.charstar.owner = TRUE;
     } else {
 	o->payload.charstar.ptr = (char*) v;
 	o->payload.charstar.owner = FALSE;
     }
     o->type = this;
 }
 
 bool QUType_charstar::canConvertFrom( QUObject *o, QUType *t )
 {
     return t->canConvertTo( o, this );
 }
 
 bool QUType_charstar::canConvertTo( QUObject *, QUType * )
 {
     return FALSE;
 }
 
 bool QUType_charstar::convertFrom( QUObject *o, QUType *t )
 {
     return t->convertTo( o, this );
 }
 
 bool QUType_charstar::convertTo( QUObject *, QUType * )
 {
     return FALSE;
 }
 
 void QUType_charstar::clear( QUObject *o )
 {
     if ( o->payload.charstar.owner )
 	delete [] o->payload.charstar.ptr;
     o->payload.charstar.ptr = 0;
 }
 
 int QUType_charstar::serializeTo( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 int QUType_charstar::serializeFrom( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 
 // Qt specific types
 
 // {44C2A547-01E7-4e56-8559-35AF9D2F42B7}
 const QUuid TID_QUType_QString( 0x44c2a547, 0x1e7, 0x4e56, 0x85, 0x59, 0x35, 0xaf, 0x9d, 0x2f, 0x42, 0xb7 );
 QUType_QString static_QUType_QString;
 const QUuid *QUType_QString::uuid() const { return &TID_QUType_QString; }
 const char *QUType_QString::desc() const { return "QString"; }
 
 void QUType_QString::set( QUObject *o, const QString& v )
 {
     o->payload.ptr = new QString( v );
     o->type = this;
 }
 
 bool QUType_QString::canConvertFrom( QUObject *o, QUType *t )
 {
     if ( isEqual( t, &static_QUType_charstar ) ||
 	 isEqual( t, &static_QUType_double ) ||
-	 isEqual( t, &static_QUType_float ) ||
 	 isEqual( t, &static_QUType_int ) )
 	return TRUE;
 
     return t->canConvertTo( o, this );
 }
 
 bool QUType_QString::canConvertTo( QUObject * /*o*/, QUType *t )
 {
     return isEqual( t, &static_QUType_charstar ) ||
 	isEqual( t,  &static_QUType_int ) ||
-	isEqual( t,  &static_QUType_double ) ||
-	isEqual( t,  &static_QUType_float );
+	isEqual( t,  &static_QUType_double );
 }
 
 bool QUType_QString::convertFrom( QUObject *o, QUType *t )
 {
     QString *str = 0;
     if ( isEqual( t, &static_QUType_charstar ) )
 	str = new QString( o->payload.charstar.ptr );
     else if ( isEqual( t, &static_QUType_double ) )
 	str = new QString( QString::number( o->payload.d ) );
-    else if ( isEqual( t, &static_QUType_float ) )
-	str = new QString( QString::number( o->payload.f ) );
     else if ( isEqual( t, &static_QUType_int ) )
 	str = new QString( QString::number( o->payload.i ) );
     else
 	return t->convertTo( o, this );
 
     o->type->clear( o );
     o->payload.ptr = str;
     o->type = this;
     return TRUE;
 }
 
 bool QUType_QString::convertTo( QUObject *o, QUType *t )
 {
     QString *str = (QString *)o->payload.ptr;
     if ( isEqual( t, &static_QUType_charstar ) ) {
 	o->payload.charstar.ptr = qstrdup( str->local8Bit().data() );
 	o->payload.charstar.owner = TRUE;
 	o->type = &static_QUType_charstar;
     } else if ( isEqual( t,  &static_QUType_int ) ) {
 	o->payload.l = str->toLong();
 	o->type = &static_QUType_int;
     } else if ( isEqual( t,  &static_QUType_double ) ) {
 	o->payload.d = str->toDouble();
 	o->type = &static_QUType_double;
-    } else if ( isEqual( t,  &static_QUType_float ) ) {
-	o->payload.d = str->toFloat();
-	o->type = &static_QUType_float;
     } else {
         return FALSE;
     }
     delete str;
     return TRUE;
 }
 
 int QUType_QString::serializeTo( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 int QUType_QString::serializeFrom( QUObject *, QUBuffer * )
 {
     return 0;
 }
 
 void QUType_QString::clear( QUObject *o )
 {
     delete (QString*)o->payload.ptr;
     o->payload.ptr = 0;
 }
diff --git a/qmake/tools/qwaitcondition_unix.cpp b/qmake/tools/qwaitcondition_unix.cpp
index 99c1014..6684617 100644
--- a/qmake/tools/qwaitcondition_unix.cpp
+++ b/qmake/tools/qwaitcondition_unix.cpp
@@ -1,310 +1,315 @@
 /****************************************************************************
 ** $Id$
 **
 ** QWaitCondition class for Unix
 **
 ** Created : 20010725
 **
 ** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the tools module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #if defined(QT_THREAD_SUPPORT)
 
 #include "qplatformdefs.h"
 
 typedef pthread_mutex_t Q_MUTEX_T;
 
 #include "qwaitcondition.h"
 #include "qmutex.h"
 #include "qmutex_p.h"
 
 #include <errno.h>
 #include <string.h>
 
 
 struct QWaitConditionPrivate {
     pthread_cond_t cond;
 };
 
 
 /*!
     \class QWaitCondition qwaitcondition.h
     \threadsafe
     \brief The QWaitCondition class allows waiting/waking for conditions between threads.
 
     \ingroup thread
     \ingroup environment
 
     QWaitConditions allow a thread to tell other threads that some
     sort of condition has been met; one or many threads can block
     waiting for a QWaitCondition to set a condition with wakeOne() or
     wakeAll(). Use wakeOne() to wake one randomly selected event or
     wakeAll() to wake them all. For example, say we have three tasks
     that should be performed every time the user presses a key; each
     task could be split into a thread, each of which would have a
     run() body like this:
 
     \code
     QWaitCondition key_pressed;
 
     for (;;) {
 	key_pressed.wait(); // This is a QWaitCondition global variable
 	// Key was pressed, do something interesting
 	do_something();
     }
     \endcode
 
     A fourth thread would read key presses and wake the other three
     threads up every time it receives one, like this:
 
     \code
     QWaitCondition key_pressed;
 
     for (;;) {
 	getchar();
 	// Causes any thread in key_pressed.wait() to return from
 	// that method and continue processing
 	key_pressed.wakeAll();
     }
     \endcode
 
     Note that the order the three threads are woken up in is
     undefined, and that if some or all of the threads are still in
     do_something() when the key is pressed, they won't be woken up
     (since they're not waiting on the condition variable) and so the
     task will not be performed for that key press. This can be
     avoided by, for example, doing something like this:
 
     \code
     QMutex mymutex;
     QWaitCondition key_pressed;
     int mycount=0;
 
     // Worker thread code
     for (;;) {
 	key_pressed.wait(); // This is a QWaitCondition global variable
 	mymutex.lock();
 	mycount++;
 	mymutex.unlock();
 	do_something();
 	mymutex.lock();
 	mycount--;
 	mymutex.unlock();
     }
 
     // Key reading thread code
     for (;;) {
 	getchar();
 	mymutex.lock();
 	// Sleep until there are no busy worker threads
-	while( count > 0 ) {
+	while( mycount > 0 ) {
 	    mymutex.unlock();
 	    sleep( 1 );
 	    mymutex.lock();
 	}
 	mymutex.unlock();
 	key_pressed.wakeAll();
     }
     \endcode
 
     The mutexes are necessary because the results of two threads
     attempting to change the value of the same variable simultaneously
     are unpredictable.
 */
 
 /*!
     Constructs a new event signalling, i.e. wait condition, object.
 */
 QWaitCondition::QWaitCondition()
 {
     d = new QWaitConditionPrivate;
 
     int ret = pthread_cond_init(&d->cond, NULL);
 
 #ifdef QT_CHECK_RANGE
     if (ret)
 	qWarning( "Wait condition init failure: %s", strerror( ret ) );
 #endif
 }
 
 
 /*!
     Deletes the event signalling, i.e. wait condition, object.
 */
 QWaitCondition::~QWaitCondition()
 {
     int ret = pthread_cond_destroy(&d->cond);
 
     if (ret) {
 #ifdef QT_CHECK_RANGE
 	qWarning( "Wait condition destroy failure: %s", strerror( ret ) );
 #endif
 
 	// seems we have threads waiting on us, lets wake them up
 	pthread_cond_broadcast(&d->cond);
     }
 
     delete d;
 }
 
 /*!
     This wakes one thread waiting on the QWaitCondition. The thread
     that is woken up depends on the operating system's scheduling
     policies, and cannot be controlled or predicted.
 
     \sa wakeAll()
 */
 void QWaitCondition::wakeOne()
 {
     int ret = pthread_cond_signal(&d->cond);
 
 #ifdef QT_CHECK_RANGE
     if (ret)
 	qWarning("Wait condition wakeOne failure: %s", strerror(ret));
 #endif
 }
 
 /*!
     This wakes all threads waiting on the QWaitCondition. The order in
     which the threads are woken up depends on the operating system's
     scheduling policies, and cannot be controlled or predicted.
 
     \sa wakeOne()
 */
 void QWaitCondition::wakeAll()
 {
     int ret = pthread_cond_broadcast(&d->cond);
 
 #ifdef QT_CHECK_RANGE
     if (ret)
 	qWarning("Wait condition wakeAll failure: %s", strerror(ret));
 #endif
 }
 
 /*!
     Wait on the thread event object. The thread calling this will
     block until either of these conditions is met:
     \list
     \i Another thread signals it using wakeOne() or wakeAll(). This
        function will return TRUE in this case.
     \i \a time milliseconds has elapsed. If \a time is ULONG_MAX (the
        default), then the wait will never timeout (the event must be
        signalled). This function will return FALSE if the wait timed
        out.
     \endlist
 
     \sa wakeOne(), wakeAll()
 */
 bool QWaitCondition::wait(unsigned long time)
 {
-    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    pthread_mutex_t mutex;
+    pthread_mutex_init( &mutex, 0 );
+    pthread_mutex_lock( &mutex );
 
     int ret;
     if (time != ULONG_MAX) {
 	struct timeval tv;
 	gettimeofday(&tv, 0);
 
 	timespec ti;
-	ti.tv_nsec = (tv.tv_usec * 1000) + (time % 1000) * 1000;
+	ti.tv_nsec = ( tv.tv_usec + ( time % 1000 ) * 1000 ) * 1000;
 	ti.tv_sec = tv.tv_sec + (time / 1000) + ( ti.tv_nsec / 1000000000 );
 	ti.tv_nsec %= 1000000000;
 
 	ret = pthread_cond_timedwait(&d->cond, &mutex, &ti);
     } else
 	ret = pthread_cond_wait(&d->cond, &mutex);
 
 #ifdef QT_CHECK_RANGE
     if (ret && ret != ETIMEDOUT)
 	qWarning("Wait condition wait failure: %s",strerror(ret));
 #endif
 
+    pthread_mutex_unlock( &mutex );
+    pthread_mutex_destroy( &mutex );
+
     return (ret == 0);
 }
 
 /*!
     \overload
 
     Release the locked \a mutex and wait on the thread event object.
     The \a mutex must be initially locked by the calling thread. If \a
     mutex is not in a locked state, this function returns immediately.
     If \a mutex is a recursive mutex, this function returns
     immediately. The \a mutex will be unlocked, and the calling thread
     will block until either of these conditions is met:
     \list
     \i Another thread signals it using wakeOne() or wakeAll(). This
        function will return TRUE in this case.
     \i \a time milliseconds has elapsed. If \a time is ULONG_MAX (the
        default), then the wait will never timeout (the event must be
        signalled). This function will return FALSE if the wait timed
        out.
     \endlist
 
     The mutex will be returned to the same locked state. This function
     is provided to allow the atomic transition from the locked state
     to the wait state.
 
     \sa wakeOne(), wakeAll()
 */
 bool QWaitCondition::wait(QMutex *mutex, unsigned long time)
 {
     if (! mutex)
 	return FALSE;
 
     if (mutex->d->type() == Q_MUTEX_RECURSIVE) {
 #ifdef QT_CHECK_RANGE
 	qWarning("Wait condition warning: using recursive mutexes with\n"
 		 "                        wait conditions is undefined!");
 #endif
 	return FALSE;
     }
 
     int ret;
     if (time != ULONG_MAX) {
 	struct timeval tv;
 	gettimeofday(&tv, 0);
 
 	timespec ti;
-	ti.tv_nsec = (tv.tv_usec * 1000) + (time % 1000) * 1000;
+	ti.tv_nsec = ( tv.tv_usec + ( time % 1000 ) * 1000 ) * 1000;
 	ti.tv_sec = tv.tv_sec + (time / 1000) + ( ti.tv_nsec / 1000000000 );
 	ti.tv_nsec %= 1000000000;
 
 	ret = pthread_cond_timedwait(&d->cond, &mutex->d->handle, &ti);
     } else
 	ret = pthread_cond_wait(&d->cond, &mutex->d->handle);
 
 #ifdef QT_CHECK_RANGE
     if (ret && ret != ETIMEDOUT)
 	qWarning("Wait condition wait failure: %s",strerror(ret));
 #endif
 
     return (ret == 0);
 }
 
 #endif // QT_THREAD_SUPPORT