#pragma working_directory "/build/test/qt-x11-commercial-src-4.1.4/src/gui"
#pragma ident "c++fe: 3.4 02/23/06 (osr600mp2.bl4ao)"
#line 1 "text/qtextengine.cpp"
#file "text/qtextengine.cpp"



















 

#line 1 "../../include/QtCore/qdebug.h"
#line 1 "../../include/QtCore/../../src/corelib/io/qdebug.h"



















 




#line 1 "../../include/QtCore/qalgorithms.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qalgorithms.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 1 "../../include/QtCore/../../src/corelib/global/qglobal.h"



















 




#line 1 "/usr/include/stddef.h"










  



#ident	"@(#)unixsrc:usr/src/common/head/stddef.h /main/legend/1"



typedef long 	ptrdiff_t;




	typedef unsigned int	size_t;

















#line 26 "../../include/QtCore/../../src/corelib/global/qglobal.h"




 




#line 1 "../../include/QtCore/qconfig.h"
 

 






 



 


























































#line 37 "../../include/QtCore/../../src/corelib/global/qglobal.h"

































 

#line 141 "../../include/QtCore/../../src/corelib/global/qglobal.h"














































 

 
#line 371 "../../include/QtCore/../../src/corelib/global/qglobal.h"






 




 
#line 406 "../../include/QtCore/../../src/corelib/global/qglobal.h"
 





 
#line 432 "../../include/QtCore/../../src/corelib/global/qglobal.h"

 
#line 493 "../../include/QtCore/../../src/corelib/global/qglobal.h"











#line 512 "../../include/QtCore/../../src/corelib/global/qglobal.h"












 

#line 547 "../../include/QtCore/../../src/corelib/global/qglobal.h"








 

typedef signed char qint8;          
typedef unsigned char quint8;       
typedef short qint16;               
typedef unsigned short quint16;     
typedef int qint32;                 
typedef unsigned int quint32;       
#line 571 "../../include/QtCore/../../src/corelib/global/qglobal.h"
typedef long long qint64;            
typedef unsigned long long quint64;  


typedef qint64 qlonglong;
typedef quint64 qulonglong;







#line 590 "../../include/QtCore/../../src/corelib/global/qglobal.h"





 

typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;







 






#line 622 "../../include/QtCore/../../src/corelib/global/qglobal.h"




 








 

#line 644 "../../include/QtCore/../../src/corelib/global/qglobal.h"



 
#line 709 "../../include/QtCore/../../src/corelib/global/qglobal.h"
 
#line 720 "../../include/QtCore/../../src/corelib/global/qglobal.h"

#line 736 "../../include/QtCore/../../src/corelib/global/qglobal.h"

typedef int QNoImplicitBoolCast;






typedef double qreal;




 

template <typename T>
inline T qAbs(const T &t) { return t >= 0 ? t : -t; }

inline int qRound(qreal d)
{ return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1); }

inline qint64 qRound64(qreal d)
{ return d >= 0.0 ? qint64(d + 0.5) : qint64(d - qint64(d-1) + 0.5) + qint64(d-1); }

template <typename T>
inline const T &qMin(const T &a, const T &b) { if (a < b) return a; return b; }
template <typename T>
inline const T &qMax(const T &a, const T &b) { if (a < b) return b; return a; }
template <typename T>
inline const T &qBound(const T &min, const T &val, const T &max)
{ return qMax(min, qMin(max, val)); }


typedef qint8 Q_INT8;
typedef quint8 Q_UINT8;
typedef qint16 Q_INT16;
typedef quint16 Q_UINT16;
typedef qint32 Q_INT32;
typedef quint32 Q_UINT32;
typedef qint64 Q_INT64;
typedef quint64 Q_UINT64;

typedef qint64 Q_LLONG;
typedef quint64 Q_ULLONG;




typedef long Q_LONG;                 
typedef unsigned long Q_ULONG;       









 

class QDataStream;

#line 815 "../../include/QtCore/../../src/corelib/global/qglobal.h"















#line 1 "../../include/QtCore/qfeatures.h"
#line 1 "../../include/QtCore/../../src/corelib/global/qfeatures.h"
















































































































































































































































































































































































































































































































































#line 2 "../../include/QtCore/qfeatures.h"
#line 831 "../../include/QtCore/../../src/corelib/global/qglobal.h"

#line 849 "../../include/QtCore/../../src/corelib/global/qglobal.h"




 

#line 930 "../../include/QtCore/../../src/corelib/global/qglobal.h"

#line 952 "../../include/QtCore/../../src/corelib/global/qglobal.h"





 
#line 965 "../../include/QtCore/../../src/corelib/global/qglobal.h"



 

class QString;
class  QSysInfo {
public:
    enum {
        WordSize = (sizeof(void *)<<3)
    };

    enum Endian {
        BigEndian,
        LittleEndian

#line 987 "../../include/QtCore/../../src/corelib/global/qglobal.h"
        , ByteOrder = LittleEndian




    };
#line 1043 "../../include/QtCore/../../src/corelib/global/qglobal.h"
};

 const char *qVersion();
 bool qSharedBuild();






inline  bool qSysInfo(int *wordSize, bool *bigEndian)
{
    *wordSize = QSysInfo::WordSize;
    *bigEndian = (QSysInfo::ByteOrder == QSysInfo::BigEndian);
    return true;
}


#line 1078 "../../include/QtCore/../../src/corelib/global/qglobal.h"

#line 1085 "../../include/QtCore/../../src/corelib/global/qglobal.h"







 

#line 1101 "../../include/QtCore/../../src/corelib/global/qglobal.h"



 









 void qDebug(const char *, ...)  



;

 void qWarning(const char *, ...)  



;

class QString;
 QString qt_error_string(int errorCode = -1);
 void qCritical(const char *, ...)  



;
 void qFatal(const char *, ...)  



;


  void qSystemWarning(const char *msg, int code = -1);

 void qErrnoWarning(int code, const char *msg, ...);
 void qErrnoWarning(const char *msg, ...);

class QDebug;
class QNoDebug;

#line 1157 "../../include/QtCore/../../src/corelib/global/qglobal.h"

inline void qt_noop() {}

 void qt_assert(const char *assertion, const char *file, int line);

#line 1169 "../../include/QtCore/../../src/corelib/global/qglobal.h"

 void qt_assert_x(const char *where, const char *what, const char *file, int line);

#line 1179 "../../include/QtCore/../../src/corelib/global/qglobal.h"

 void qt_check_pointer(const char *, int);







enum QtMsgType { QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtSystemMsg = QtCriticalMsg };

 void qt_message_output(QtMsgType, const char *buf);

typedef void (*QtMsgHandler)(QtMsgType, const char *);
 QtMsgHandler qInstallMsgHandler(QtMsgHandler);


inline  void qSuppressObsoleteWarnings(bool = true) {}
inline  void qObsolete(const char *, const char * = 0, const char * = 0) {}


#line 1228 "../../include/QtCore/../../src/corelib/global/qglobal.h"

template <typename T>
class QGlobalStatic
{
public:
    T *pointer;
    bool destroyed;

    inline QGlobalStatic()
        : pointer(0), destroyed(false)
    { }

    inline ~QGlobalStatic()
    {
        delete pointer;
        pointer = 0;
        destroyed = true;
    }
};

#line 1259 "../../include/QtCore/../../src/corelib/global/qglobal.h"

#line 1271 "../../include/QtCore/../../src/corelib/global/qglobal.h"



class QBool
{
    bool b;

public:
    inline explicit QBool(bool B) : b(B) {}
    inline operator const void *() const
    { return b ? static_cast<const void *>(this) : static_cast<const void *>(0); }
};

inline bool operator==(QBool b1, bool b2) { return !b1 == !b2; }
inline bool operator==(bool b1, QBool b2) { return !b1 == !b2; }
inline bool operator==(QBool b1, QBool b2) { return !b1 == !b2; }
inline bool operator!=(QBool b1, bool b2) { return !b1 != !b2; }
inline bool operator!=(bool b1, QBool b2) { return !b1 != !b2; }
inline bool operator!=(QBool b1, QBool b2) { return !b1 != !b2; }

static inline bool qFuzzyCompare(double p1, double p2)
{
    return qAbs(p1 - p2) < 0.00000000001;
}

static inline bool qFuzzyCompare(float p1, float p2)
{
    return qAbs(p1 - p2) < 0.000001;
}





 
static inline bool qIsNull(double d)
{
    union U {
        double d;
        quint64 u;
    };
    U val;
    val.d = d;
    return val.u == quint64(0);
}





 
static inline bool qIsNull(float f)
{
    union U {
        float f;
        quint32 u;
    };
    U val;
    val.f = f;
    return val.u == 0u;
}








 

#line 1351 "../../include/QtCore/../../src/corelib/global/qglobal.h"





 





 

template <typename T> inline bool qIsDetached(T &) { return true; }

template <typename T>
class QTypeInfo
{
public:
    enum {
        isPointer = false,
        isComplex = true,
        isStatic = true,
        isLarge = (sizeof(T)>sizeof(void*)),
        isDummy = false
    };
};

template <typename T>
class QTypeInfo<T*>
{
public:
    enum {
        isPointer = true,
        isComplex = false,
        isStatic = false,
        isLarge = false,
        isDummy = false
    };
};

#line 1413 "../../include/QtCore/../../src/corelib/global/qglobal.h"








 
enum {  
    Q_COMPLEX_TYPE = 0,
    Q_PRIMITIVE_TYPE = 0x1,
    Q_STATIC_TYPE = 0,
    Q_MOVABLE_TYPE = 0x2,
    Q_DUMMY_TYPE = 0x4
};

#line 1444 "../../include/QtCore/../../src/corelib/global/qglobal.h"









 





 
template <> class QTypeInfo<bool> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(bool)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "bool"; } };
template <> class QTypeInfo<char> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(char)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "char"; } };
template <> class QTypeInfo<signed char> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(signed char)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "signed char"; } };
template <> class QTypeInfo<uchar> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(uchar)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "uchar"; } };
template <> class QTypeInfo<short> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(short)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "short"; } };
template <> class QTypeInfo<ushort> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(ushort)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "ushort"; } };
template <> class QTypeInfo<int> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(int)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "int"; } };
template <> class QTypeInfo<uint> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(uint)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "uint"; } };
template <> class QTypeInfo<long> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(long)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "long"; } };
template <> class QTypeInfo<ulong> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(ulong)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "ulong"; } };
template <> class QTypeInfo<qint64> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(qint64)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "qint64"; } };
template <> class QTypeInfo<quint64> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(quint64)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "quint64"; } };
template <> class QTypeInfo<float> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(float)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "float"; } };
template <> class QTypeInfo<double> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(double)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "double"; } };

template <> class QTypeInfo<long double> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(long double)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "long double"; } };





 
 void *qMalloc(size_t size);
 void qFree(void *ptr);
 void *qRealloc(void *ptr, size_t size);
 void *qMemCopy(void *dest, const void *src, size_t n);
 void *qMemSet(void *dest, int c, size_t n);






 
#line 1522 "../../include/QtCore/../../src/corelib/global/qglobal.h"

class  QFlag
{
    int i;
public:
    inline QFlag(int i);
    inline operator int() const { return i; }
};

inline QFlag::QFlag(int ai) : i(ai) {}




template<typename Enum>
class QFlags
{
    typedef void **Zero;
    int i;
public:
    typedef Enum enum_type;
    inline QFlags(const QFlags &f) : i(f.i) {}
    inline QFlags(Enum f) : i(f) {}
    inline QFlags(Zero = 0) : i(0) {}
    inline QFlags(QFlag f) : i(f) {}

    inline QFlags &operator=(const QFlags &f) { i = f.i; return *this; }
    inline QFlags &operator&=(int mask) {  i &= mask; return *this; }
    inline QFlags &operator&=(uint mask) {  i &= mask; return *this; }
    inline QFlags &operator|=(QFlags f) {  i |= f.i; return *this; }
    inline QFlags &operator|=(Enum f) {  i |= f; return *this; }
    inline QFlags &operator^=(QFlags f) {  i ^= f.i; return *this; }
    inline QFlags &operator^=(Enum f) {  i ^= f; return *this; }


    inline operator int() const { return i;}

    inline QFlags operator|(QFlags f) const { QFlags g; g.i = i | f.i; return g; }
    inline QFlags operator|(Enum f) const { QFlags g; g.i = i | f; return g; }
    inline QFlags operator^(QFlags f) const { QFlags g; g.i = i ^ f.i; return g; }
    inline QFlags operator^(Enum f) const { QFlags g; g.i = i ^ f; return g; }
    inline QFlags operator&(int mask) const { QFlags g; g.i = i & mask; return g; }
    inline QFlags operator&(uint mask) const { QFlags g; g.i = i & mask; return g; }
    inline QFlags operator&(Enum f) const { QFlags g; g.i = i & f; return g; }
    inline QFlags operator~() const { QFlags g; g.i = ~i; return g; }

    inline bool operator!() const { return !i; }
};

#line 1578 "../../include/QtCore/../../src/corelib/global/qglobal.h"

#line 1586 "../../include/QtCore/../../src/corelib/global/qglobal.h"

#line 1605 "../../include/QtCore/../../src/corelib/global/qglobal.h"

struct QForeachContainerBase {};

template <typename T>
class QForeachContainer : public QForeachContainerBase {
public:
    inline QForeachContainer(const T& t): c(t), brk(0), i(c.begin()), e(c.end()){};
    const T c;
    mutable int brk;
    mutable typename T::const_iterator i, e;
    inline bool condition() const { return (!brk++ && i != e); }
};

template <typename T> inline T *qForeachPointer(const T &) { return 0; }

template <typename T> inline QForeachContainer<T> qForeachContainerNew(const T& t)
{ return QForeachContainer<T>(t); }

template <typename T>
inline const QForeachContainer<T> *qForeachContainer(const QForeachContainerBase *base, const T *)
{ return static_cast<const QForeachContainer<T> *>(base); }

#line 1634 "../../include/QtCore/../../src/corelib/global/qglobal.h"



#line 1646 "../../include/QtCore/../../src/corelib/global/qglobal.h"

#line 1654 "../../include/QtCore/../../src/corelib/global/qglobal.h"






















 

#line 1685 "../../include/QtCore/../../src/corelib/global/qglobal.h"

class QByteArray;
 QByteArray qgetenv(const char *varName);

inline int qIntCast(double f) { return int(f); }
inline int qIntCast(float f) { return int(f); }




 
#line 1703 "../../include/QtCore/../../src/corelib/global/qglobal.h"
  const char *qInstallPath();
  const char *qInstallPathDocs();
  const char *qInstallPathHeaders();
  const char *qInstallPathLibs();
  const char *qInstallPathBins();
  const char *qInstallPathPlugins();
  const char *qInstallPathData();
  const char *qInstallPathTranslations();
  const char *qInstallPathSysconf();





 

 
#line 1730 "../../include/QtCore/../../src/corelib/global/qglobal.h"

 
#line 1754 "../../include/QtCore/../../src/corelib/global/qglobal.h"

 
#line 1763 "../../include/QtCore/../../src/corelib/global/qglobal.h"





enum QtValidLicenseForCoreModule { LicensedCore = true };


enum QtValidLicenseForGuiModule { LicensedGui = true };


enum QtValidLicenseForNetworkModule { LicensedNetwork = true };


enum QtValidLicenseForOpenGLModule { LicensedOpenGL = true };


enum QtValidLicenseForSqlModule { LicensedSql = true };


enum QtValidLicenseForXmlModule { LicensedXml = true };


enum QtValidLicenseForQt3SupportLightModule { LicensedQt3SupportLight = true };


enum QtValidLicenseForQt3SupportModule { LicensedQt3Support = true };


enum QtValidLicenseForSvgModule { LicensedSvg = true };


enum QtValidLicenseForActiveQtModule { LicensedActiveQt = true };









#line 2 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qalgorithms.h"



typedef QtValidLicenseForCoreModule QtCoreModule;




 
namespace QAlgorithmsPrivate {

template <typename BiIterator, typename T, typename LessThan>
 void qSortHelper(BiIterator start, BiIterator end, const T &t, LessThan lessThan);
template <typename BiIterator, typename T>
inline void qSortHelper(BiIterator begin, BiIterator end, const T &dummy);

template <typename BiIterator, typename T, typename LessThan>
 void qStableSortHelper(BiIterator start, BiIterator end, const T &t, LessThan lessThan);
template <typename BiIterator, typename T>
inline void qStableSortHelper(BiIterator, BiIterator, const T &);

}

template <typename InputIterator, typename OutputIterator>
inline OutputIterator qCopy(InputIterator begin, InputIterator end, OutputIterator dest)
{
    while (begin != end)
        *dest++ = *begin++;
    return dest;
}

template <typename BiIterator1, typename BiIterator2>
inline BiIterator2 qCopyBackward(BiIterator1 begin, BiIterator1 end, BiIterator2 dest)
{
    while (begin != end)
        *--dest = *--end;
    return dest;
}

template <typename InputIterator1, typename InputIterator2>
inline bool qEqual(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
{
    for (; first1 != last1; ++first1, ++first2)
        if (!(*first1 == *first2))
            return false;
    return true;
}

template <typename ForwardIterator, typename T>
inline void qFill(ForwardIterator first, ForwardIterator last, const T &val)
{
    for (; first != last; ++first)
        *first = val;
}

template <typename InputIterator, typename T>
inline InputIterator qFind(InputIterator first, InputIterator last, const T &val)
{
    while (first != last && !(*first == val))
        ++first;
    return first;
}

template <typename InputIterator, typename T, typename Size>
inline void qCount(InputIterator first, InputIterator last, const T &value, Size &n)
{
    for (; first != last; ++first)
        if (*first == value)
            ++n;
}

template <typename T>
inline void qSwap(T &value1, T &value2)
{
    if (!QTypeInfo<T>::isComplex || QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        T t = value1;
        value1 = value2;
        value2 = t;
    } else {
        const void * const t = reinterpret_cast<const void * const &>(value1);
        const_cast<const void *&>(reinterpret_cast<const void * const &>(value1)) =
            reinterpret_cast<const void * const &>(value2);
        const_cast<const void *&>(reinterpret_cast<const void * const &>(value2)) = t;
    }
}

template <typename T>
class qLess
{
public:
    inline bool operator()(const T &t1, const T &t2) const
    {
        return (t1 < t2);
    }
};

template <typename T>
class qGreater
{
public:
    inline bool operator()(const T &t1, const T &t2) const
    {
        return (t2 < t1);
    }
};

template <typename BiIterator>
inline void qSort(BiIterator start, BiIterator end)
{
    if (start != end)
        QAlgorithmsPrivate::qSortHelper(start, end, *start);
}

template <typename BiIterator, typename LessThan>
inline void qSort(BiIterator start, BiIterator end, LessThan lessThan)
{
    if (start != end)
        QAlgorithmsPrivate::qSortHelper(start, end, *start, lessThan);
}

template<typename Container>
inline void qSort(Container &c)
{




    if (!c.empty())
        QAlgorithmsPrivate::qSortHelper(c.begin(), c.end(), *c.begin());
}

template <typename BiIterator>
inline void qStableSort(BiIterator start, BiIterator end)
{
    if (start != end)
        QAlgorithmsPrivate::qStableSortHelper(start, end, *start);
}

template <typename BiIterator, typename LessThan>
inline void qStableSort(BiIterator start, BiIterator end, LessThan lessThan)
{
    if (start != end)
        QAlgorithmsPrivate::qStableSortHelper(start, end, *start, lessThan);
}

template<typename Container>
inline void qStableSort(Container &c)
{




    if (!c.empty())
        QAlgorithmsPrivate::qStableSortHelper(c.begin(), c.end(), *c.begin());
}

template <typename RandomAccessIterator, typename T>
 RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
{
    RandomAccessIterator middle;
    int n = end - begin;
    int half;

    while (n > 0) {
        half = n >> 1;
        middle = begin + half;
        if (*middle < value) {
            begin = middle + 1;
            n -= half + 1;
        } else {
            n = half;
        }
    }
    return begin;
}

template <typename RandomAccessIterator, typename T>
 RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
{
    RandomAccessIterator middle;
    int n = end - begin;
    int half;

    while (n > 0) {
        half = n >> 1;
        middle = begin + half;
        if (value < *middle) {
            n = half;
        } else {
            begin = middle + 1;
            n -= half + 1;
        }
    }
    return begin;
}

template <typename RandomAccessIterator, typename T>
 RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
{
    int l = 0;
    int r = end - begin - 1;
    if (r < 0)
        return end;
    int i = (l + r + 1) / 2;

    while (r != l) {
        if (value < begin[i])
            r = i - 1;
        else
            l = i;
        i = (l + r + 1) / 2;
    }
    if (begin[i] < value || value < begin[i])
        return end;
    else
        return begin + i;
}

template <typename ForwardIterator>
 void qDeleteAll(ForwardIterator begin, ForwardIterator end)
{
    while (begin != end) {
        delete *begin;
        ++begin;
    }
}

template <typename Container>
inline void qDeleteAll(const Container &c)
{
    qDeleteAll(c.begin(), c.end());
}




 
namespace QAlgorithmsPrivate {

template <typename BiIterator, typename T, typename LessThan>
 void qSortHelper(BiIterator start, BiIterator end, const T &t, LessThan lessThan)
{
top:
    int span = end - start;
    if (span < 2)
        return;

    --end;
    BiIterator low = start, high = end - 1;
    BiIterator pivot = start + span / 2;

    if (lessThan(*end, *start))
        qSwap(*end, *start);
    if (span == 2)
        return;

    if (lessThan(*pivot, *start))
        qSwap(*pivot, *start);
    if (lessThan(*end, *pivot))
        qSwap(*end, *pivot);
    if (span == 3)
        return;

    qSwap(*pivot, *end);

    while (low < high) {
        while (low < high && lessThan(*low, *end))
            ++low;

        while (high > low && lessThan(*end, *high))
            --high;

        if (low < high) {
            qSwap(*low, *high);
            ++low;
            --high;
        } else {
            break;
        }
    }

    if (lessThan(*low, *end))
        ++low;

    qSwap(*end, *low);
    qSortHelper(start, low, t, lessThan);

    start = low + 1;
    ++end;
    goto top;
}

template <typename BiIterator, typename T>
inline void qSortHelper(BiIterator begin, BiIterator end, const T &dummy)
{
    qSortHelper(begin, end, dummy, qLess<T>());
}

template <typename BiIterator, typename T, typename LessThan>
 void qStableSortHelper(BiIterator start, BiIterator end, const T &t, LessThan lessThan)
{
    const int span = end - start;
    if (span < 2)
       return;
        
    
    BiIterator middle = start + span / 2;
    qStableSortHelper(start, middle, t, lessThan);
    qStableSortHelper(middle, end, t, lessThan);
    
    
    BiIterator lo = start;
    BiIterator hi = middle;
    
    while (lo != middle && hi != end) {
        if (!lessThan(*hi, *lo)) {
            ++lo; 
        } else {
            
            
            T value = *hi;
            for (BiIterator i = hi; i != lo; --i) {
                *i = *(i-1); 
            }
            *lo = value;
            ++hi;
            ++lo;
            ++middle;
        } 
    }
}

template <typename BiIterator, typename T>
inline void qStableSortHelper(BiIterator begin, BiIterator end, const T &dummy)
{
    qStableSortHelper(begin, end, dummy, qLess<T>());
}

} 



#line 2 "../../include/QtCore/qalgorithms.h"
#line 26 "../../include/QtCore/../../src/corelib/io/qdebug.h"
#line 1 "../../include/QtCore/qhash.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qhash.h"



















 




#line 1 "../../include/QtCore/qatomic.h"
#line 1 "../../include/QtCore/../../src/corelib/thread/qatomic.h"
 


















 




#line 1 "../../include/QtCore/arch/qatomic.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtCore/arch/qatomic.h"



#line 100 "../../include/QtCore/arch/qatomic.h"

extern "C" {
     int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval);
     int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval);
     int q_atomic_increment(volatile int *ptr);
     int q_atomic_decrement(volatile int *ptr);
     int q_atomic_set_int(volatile int *ptr, int newval);
     void *q_atomic_set_ptr(volatile void *ptr, void *newval);
} 

inline int q_atomic_test_and_set_acquire_int(volatile int *ptr, int expected, int newval)
{
    return q_atomic_test_and_set_int(ptr, expected, newval);
}

inline int q_atomic_test_and_set_release_int(volatile int *ptr, int expected, int newval)
{
    return q_atomic_test_and_set_int(ptr, expected, newval);
}





#line 30 "../../include/QtCore/../../src/corelib/thread/qatomic.h"
#line 1 "../../include/QtCore/qglobal.h"
#line 32 "../../include/QtCore/../../src/corelib/thread/qatomic.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

























 

struct QBasicAtomic {
    volatile int atomic;

    void init(int x = 0)
    { atomic = x; }

    inline bool ref()
    { return q_atomic_increment(&atomic) != 0; }

    inline bool deref()
    { return q_atomic_decrement(&atomic) != 0; }

    inline bool operator==(int x) const
    { return atomic == x; }

    inline bool operator!=(int x) const
    { return atomic != x; }

    inline bool operator!() const
    { return atomic == 0; }

    inline operator int() const
    { return atomic; }

    inline QBasicAtomic &operator=(int x)
    {
        (void) q_atomic_set_int(&atomic, x);
        return *this;
    }

    inline bool testAndSet(int expected, int newval)
    { return q_atomic_test_and_set_int(&atomic, expected, newval) != 0; }

    inline bool testAndSetAcquire(int expected, int newval)
    { return q_atomic_test_and_set_acquire_int(&atomic, expected, newval) != 0; }

    inline bool testAndSetRelease(int expected, int newval)
    { return q_atomic_test_and_set_release_int(&atomic, expected, newval) != 0; }

    inline int exchange(int newval)
    { return q_atomic_set_int(&atomic, newval); }
};

template <typename T>
struct QBasicAtomicPointer
{
    volatile T *pointer;

    void init(T *t = 0)
    { pointer = t; }

    inline bool operator==(T *t) const
    { return pointer == t; }

    inline bool operator!=(T *t) const
    { return !operator==(t); }

    inline bool operator!() const
    { return operator==(0); }

    inline operator T *() const
    { return const_cast<T *>(pointer); }

    inline T *operator->() const
    { return const_cast<T *>(pointer); }

    inline QBasicAtomicPointer<T> &operator=(T *t)
    {
        (void) q_atomic_set_ptr(&pointer, t);
        return *this;
    }

    inline bool testAndSet(T *expected, T *newval)
    { return q_atomic_test_and_set_ptr(&pointer, expected, newval); }

    inline T *exchange(T * newval)
    { return static_cast<T *>(q_atomic_set_ptr(&pointer, newval)); }
};





template <typename T>
inline T qAtomicSetPtr(volatile T *ptr, T newval)
{ return static_cast<T>(q_atomic_set_ptr(ptr, newval)); }


class QAtomic : public QBasicAtomic
{
public:
    inline QAtomic(int x = 0)
    { init(x); }
    inline QAtomic(const QAtomic &copy)
    { init(copy); }

    inline QAtomic &operator=(int x)
    {
        (void) QBasicAtomic::operator=(x);
        return *this;
    }

    inline QAtomic &operator=(const QAtomic &copy)
    {
        (void) QBasicAtomic::operator=(copy);
        return *this;
    }
};


template <typename T>
class QAtomicPointer : public QBasicAtomicPointer<T>
{
public:
    inline QAtomicPointer(T *t = 0)
    { init(t); }
    inline QAtomicPointer(const QAtomicPointer<T> &copy)
    { init(copy); }

    inline QAtomicPointer<T> &operator=(T *t)
    {
        (void) QBasicAtomicPointer<T>::operator=(t);
        return *this;
    }

    inline QAtomicPointer<T> &operator=(const QAtomicPointer<T> &copy)
    {
        (void) QBasicAtomicPointer<T>::operator=(copy);
        return *this;
    }
};









 
template <typename T>
inline void qAtomicAssign(T *&d, T *x)
{
    x->ref.ref();
    x = qAtomicSetPtr(&d, x);
    if (!x->ref.deref())
        delete x;
}



 
template <typename T>
inline void qAtomicAssign(QBasicAtomicPointer<T> &d, T *x)
{
    x->ref.ref();
    x = d.exchange(x);
    if (!x->ref.deref())
        delete x;
}



 
template <typename T>
inline void qAtomicAssign(QBasicAtomicPointer<T> &d, const QBasicAtomicPointer<T> &x)
{ qAtomicAssign<T>(d, x); }










 
template <typename T>
inline void qAtomicDetach(T *&d)
{
    if (d->ref == 1)
        return;
    T *x = new T(*d);
    x = qAtomicSetPtr(&d, x);
    if (!x->ref.deref())
        delete x;
}



 
template <typename T>
inline void qAtomicDetach(QBasicAtomicPointer<T> &d)
{
    if (d->ref == 1)
        return;
    T *x = new T(*d);
    x = d.exchange(x);
    if (!x->ref.deref())
        delete x;
}



#line 2 "../../include/QtCore/qatomic.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qhash.h"
#line 1 "../../include/QtCore/qchar.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qchar.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qchar.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class QString;

struct QLatin1Char
{
public:
    inline explicit QLatin1Char(char c) : ch(c) {}
    inline const char toLatin1() const { return ch; }
    inline const ushort unicode() const { return ushort(uchar(ch)); }

private:
    char ch;
};


class  QChar {
public:
    QChar();

    QChar(char c);
    QChar(uchar c);

    QChar(QLatin1Char ch);
    QChar(uchar c, uchar r);
    inline QChar(ushort rc) : ucs(rc){}
    QChar(short rc);
    QChar(uint rc);
    QChar(int rc);
    enum SpecialCharacter {
        Null = 0x0000,
        Nbsp = 0x00a0,
        ReplacementCharacter = 0xfffd,
        ObjectReplacementCharacter = 0xfffc,
        ByteOrderMark = 0xfeff,
        ByteOrderSwapped = 0xfffe,

        null = Null,
        replacement = ReplacementCharacter,
        byteOrderMark = ByteOrderMark,
        byteOrderSwapped = ByteOrderSwapped,
        nbsp = Nbsp,

        ParagraphSeparator = 0x2029,
        LineSeparator = 0x2028
    };
    QChar(SpecialCharacter sc);

    

    enum Category
    {
        NoCategory,

        Mark_NonSpacing,          
        Mark_SpacingCombining,    
        Mark_Enclosing,           

        Number_DecimalDigit,      
        Number_Letter,            
        Number_Other,             

        Separator_Space,          
        Separator_Line,           
        Separator_Paragraph,      

        Other_Control,            
        Other_Format,             
        Other_Surrogate,          
        Other_PrivateUse,         
        Other_NotAssigned,        

        Letter_Uppercase,         
        Letter_Lowercase,         
        Letter_Titlecase,         
        Letter_Modifier,          
        Letter_Other,             

        Punctuation_Connector,    
        Punctuation_Dash,         
        Punctuation_Open,         
        Punctuation_Close,        
        Punctuation_InitialQuote, 
        Punctuation_FinalQuote,   
        Punctuation_Other,        

        Symbol_Math,              
        Symbol_Currency,          
        Symbol_Modifier,          
        Symbol_Other,             

        Punctuation_Dask = Punctuation_Dash 
    };

    enum Direction
    {
        DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
        DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
    };

    enum Decomposition
    {
        NoDecomposition,
        Canonical,
        Font,
        NoBreak,
        Initial,
        Medial,
        Final,
        Isolated,
        Circle,
        Super,
        Sub,
        Vertical,
        Wide,
        Narrow,
        Small,
        Square,
        Compat,
        Fraction


        , Single = NoDecomposition

    };

    enum Joining
    {
        OtherJoining, Dual, Right, Center
    };

    enum CombiningClass
    {
        Combining_BelowLeftAttached       = 200,
        Combining_BelowAttached           = 202,
        Combining_BelowRightAttached      = 204,
        Combining_LeftAttached            = 208,
        Combining_RightAttached           = 210,
        Combining_AboveLeftAttached       = 212,
        Combining_AboveAttached           = 214,
        Combining_AboveRightAttached      = 216,

        Combining_BelowLeft               = 218,
        Combining_Below                   = 220,
        Combining_BelowRight              = 222,
        Combining_Left                    = 224,
        Combining_Right                   = 226,
        Combining_AboveLeft               = 228,
        Combining_Above                   = 230,
        Combining_AboveRight              = 232,

        Combining_DoubleBelow             = 233,
        Combining_DoubleAbove             = 234,
        Combining_IotaSubscript           = 240
    };

    enum UnicodeVersion {
        Unicode_Unassigned,
        Unicode_1_1,
        Unicode_2_0,
        Unicode_2_1_2,
        Unicode_3_0,
        Unicode_3_1,
        Unicode_3_2,
        Unicode_4_0
    };
    

    int digitValue() const;
    QChar toLower() const;
    QChar toUpper() const;

    Category category() const;
    Direction direction() const;
    Joining joining() const;
    bool hasMirrored() const;
    inline bool isLower() const { return category() == Letter_Lowercase; }
    inline bool isUpper() const { return category() == Letter_Uppercase; }


    inline  bool mirrored() const { return hasMirrored(); }

    QChar mirroredChar() const;
    QString decomposition() const;
    Decomposition decompositionTag() const;
    unsigned char combiningClass() const;

    UnicodeVersion unicodeVersion() const;

    const char toAscii() const;
    inline const char toLatin1() const;
    inline const ushort unicode() const { return ucs; }



    inline ushort &unicode() { return ucs; }


    static QChar fromAscii(char c);
    static QChar fromLatin1(char c);

    inline bool isNull() const { return ucs == 0; }
    bool isPrint() const;
    bool isPunct() const;
    bool isSpace() const;
    bool isMark() const;
    bool isLetter() const;
    bool isNumber() const;
    bool isLetterOrNumber() const;
    bool isDigit() const;
    bool isSymbol() const;

    inline uchar cell() const { return uchar(ucs & 0xff); }
    inline uchar row() const { return uchar((ucs>>8)&0xff); }
    inline void setCell(uchar cell);
    inline void setRow(uchar row);


    inline  QChar lower() const { return toLower(); }
    inline  QChar upper() const { return toUpper(); }
    static inline  bool networkOrdered() {
        return QSysInfo::ByteOrder == QSysInfo::BigEndian;
    }
    inline  const char latin1() const { return toLatin1(); }
    inline  const char ascii() const { return toAscii(); }


private:




    ushort ucs;
} ;

template <> class QTypeInfo<QChar> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QChar)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QChar"; } };

inline QChar::QChar() : ucs(0) {}

inline const char QChar::toLatin1() const { return ucs > 0xff ? '\0' : char(ucs); }
inline QChar QChar::fromLatin1(char c) { return QChar(ushort(uchar(c))); }

inline QChar::QChar(uchar c, uchar r) : ucs((ushort(r) << 8) | c){}
inline QChar::QChar(short rc) : ucs(ushort(rc)){}
inline QChar::QChar(uint rc) : ucs(ushort(rc & 0xffff)){}
inline QChar::QChar(int rc) : ucs(ushort(rc & 0xffff)){}
inline QChar::QChar(SpecialCharacter s) : ucs(ushort(s)) {}
inline QChar::QChar(QLatin1Char ch) : ucs(ch.unicode()) {}

inline void QChar::setCell(uchar acell)
{ ucs = (ucs & 0xff00) + acell; }
inline void QChar::setRow(uchar arow)
{ ucs = (ushort(arow)<<8) + (ucs&0xff); }

inline bool operator==(QChar c1, QChar c2) { return c1.unicode() == c2.unicode(); }
inline bool operator!=(QChar c1, QChar c2) { return c1.unicode() != c2.unicode(); }
inline bool operator<=(QChar c1, QChar c2) { return c1.unicode() <= c2.unicode(); }
inline bool operator>=(QChar c1, QChar c2) { return c1.unicode() >= c2.unicode(); }
inline bool operator<(QChar c1, QChar c2) { return c1.unicode() < c2.unicode(); }
inline bool operator>(QChar c1, QChar c2) { return c1.unicode() > c2.unicode(); }


 QDataStream &operator<<(QDataStream &, const QChar &);
 QDataStream &operator>>(QDataStream &, QChar &);




#line 2 "../../include/QtCore/qchar.h"
#line 27 "../../include/QtCore/../../src/corelib/tools/qhash.h"
#line 1 "../../include/QtCore/qiterator.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qiterator.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qiterator.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

namespace std { struct bidirectional_iterator_tag; struct random_access_iterator_tag; }

#line 60 "../../include/QtCore/../../src/corelib/tools/qiterator.h"

#line 99 "../../include/QtCore/../../src/corelib/tools/qiterator.h"

#line 131 "../../include/QtCore/../../src/corelib/tools/qiterator.h"

#line 170 "../../include/QtCore/../../src/corelib/tools/qiterator.h"



#line 2 "../../include/QtCore/qiterator.h"
#line 28 "../../include/QtCore/../../src/corelib/tools/qhash.h"
#line 1 "../../include/QtCore/qlist.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qlist.h"



















 




#line 1 "../../include/QtCore/qiterator.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qlist.h"
#line 1 "../../include/QtCore/qatomic.h"
#line 27 "../../include/QtCore/../../src/corelib/tools/qlist.h"
#line 1 "../../include/QtCore/qalgorithms.h"
#line 28 "../../include/QtCore/../../src/corelib/tools/qlist.h"

#line 1 "/usr/include/CC/iterator"

#line 1 "/usr/include/CC/xutility"

#line 1 "/usr/include/CC/climits"

#line 1 "/usr/include/limits.h"










  



#ident	"@(#)unixsrc:usr/src/i386/head/limits.h /main/1"








#line 39 "/usr/include/limits.h"









#line 56 "/usr/include/limits.h"







































#line 108 "/usr/include/limits.h"

#line 117 "/usr/include/limits.h"

#line 126 "/usr/include/limits.h"





#line 137 "/usr/include/limits.h"



#line 146 "/usr/include/limits.h"




#line 158 "/usr/include/limits.h"



































#line 200 "/usr/include/limits.h"










extern "C" {


extern long	_sysconf(int);


}








#line 5 "/usr/include/CC/climits"

#line 12 "/usr/include/CC/climits"






 
#line 5 "/usr/include/CC/xutility"
#line 1 "/usr/include/CC/utility"

#line 1 "/usr/include/CC/iosfwd"

#line 1 "/usr/include/CC/cstdio"

#line 1 "/usr/include/stdio.h"










  



#ident	"@(#)unixsrc:usr/src/i386/head/stdio.h /main/2"

#line 1 "/usr/include/sys/types.h"










  





#ident	"@(#)unixsrc:usr/src/i386/uts/util/types.h /main/osr600mp2/2"



 




 


typedef char		int8_t;




typedef unsigned char	uint8_t;




typedef short		int16_t;




typedef unsigned short	uint16_t;




typedef int		int32_t;




typedef unsigned int	uint32_t;




typedef int		t_scalar_t;




typedef unsigned int	t_uscalar_t;



 


typedef long		intptr_t;




typedef unsigned long	uintptr_t;






 
#line 102 "/usr/include/sys/types.h"



typedef long long int64_t;




typedef unsigned long long uint64_t;




typedef	unsigned char	uchar_t;



typedef	unsigned short	ushort_t;


typedef	unsigned int	uint_t;



typedef	unsigned long	ulong_t;




typedef unsigned long useconds_t;




typedef	unsigned long long	ullong_t;




typedef	long long	llong_t;


 
typedef	long	daddr_t;		 
typedef	char *	caddr_t;		 
typedef char *	addr_t;			 
typedef char *	faddr_t;		 

#line 156 "/usr/include/sys/types.h"



 

 
typedef long		off32_t;
typedef llong_t		off64_t;
typedef long		n_off_t;
typedef ulong_t		uoff32_t;
typedef ullong_t	uoff64_t;
typedef ulong_t		n_uoff_t;

 
typedef unsigned short	ino16_t;
typedef ulong_t		ino32_t;
typedef ullong_t 	ino64_t;
typedef ulong_t		n_ino_t;

 
typedef long		blkcnt32_t;
typedef	llong_t		blkcnt64_t;
typedef long		n_blkcnt_t;

 
typedef ulong_t		fsblkcnt32_t;
typedef ullong_t	fsblkcnt64_t;
typedef ulong_t		n_fsblkcnt_t;

 
typedef ulong_t		fsfilcnt32_t;
typedef ullong_t	fsfilcnt64_t;
typedef ulong_t		n_fsfilcnt_t;

#line 222 "/usr/include/sys/types.h"


typedef n_off_t		off_t;
typedef n_uoff_t	uoff_t;
typedef n_ino_t		ino_t;
typedef n_blkcnt_t	blkcnt_t;
typedef n_fsblkcnt_t	fsblkcnt_t;
typedef n_fsfilcnt_t	fsfilcnt_t;
#line 252 "/usr/include/sys/types.h"



typedef	short	cnt_t;			 
typedef	ulong_t	vaddr_t;		 
typedef	ulong_t	paddr_t;		 
typedef uint_t	ppid_t;			 
typedef	uchar_t	use_t;			 
typedef	short	sysid_t;		 
typedef	short	index_t;		 

typedef ulong_t paddr32_t;		 
typedef ullong_t paddr64_t;		 




 


typedef	uint_t	rm_key_t;




typedef enum __boolean { B_FALSE, B_TRUE } boolean_t;
typedef	struct _label { int val[6]; } label_t;
typedef struct _quad { long val[2]; } quad;	 









 



typedef long	id_t;		 

				 
				 
				 
				 

 
typedef unsigned long long memsize_t;

 
typedef	long	lwpid_t;

 
typedef long long cgid_t;

 
typedef int	cgnum_t;

 
typedef	int	processorid_t;

 
typedef	int	toid_t;

 

typedef ulong_t	pvec_t;		 

 

typedef ulong_t	lid_t;		 

typedef lid_t	level_t;	 
				 

 

typedef ulong_t	major_t;	 
typedef ulong_t	minor_t;	 




 

typedef unsigned long  adtemask_t[8];  












 
typedef	ushort_t o_mode_t;		 
typedef short	 o_dev_t;		 
typedef	ushort_t o_uid_t;		 
typedef	o_uid_t	 o_gid_t;		 
typedef	short	 o_nlink_t;		 
typedef short	 o_pid_t;		 
typedef ushort_t o_ino_t;		 


 



typedef	int	key_t;			 




typedef	ulong_t	mode_t;			 




typedef	long	uid_t;			 




typedef	uid_t	gid_t;			 




typedef	ulong_t nlink_t;		 




typedef ulong_t	dev_t;			 




typedef long	pid_t;			 




typedef id_t	thread_t;		 




typedef thread_t	pthread_t;	 









typedef int ssize_t;		 




typedef	long	time_t;		 




typedef	long	clock_t;	 



#line 454 "/usr/include/sys/types.h"





typedef	struct { int r[1]; } *	physadr;
typedef	unsigned char	unchar;
typedef	unsigned short	ushort;
typedef	unsigned int	uint;
typedef	unsigned long	ulong;

#line 502 "/usr/include/sys/types.h"








 











 

typedef	long	hostid_t;





 



typedef unsigned char	u_char;
typedef unsigned short	u_short;
typedef unsigned int	u_int;
typedef unsigned long	u_long;

typedef	unsigned int	pl_t;		 





 
typedef	uchar_t		k_pl_t;




 
#line 561 "/usr/include/sys/types.h"

#line 1 "/usr/include/sys/select.h"


#ident	"@(#)unixsrc:usr/src/common/uts/fs/select.h /main/1"








 






 








typedef	long	fd_mask;




typedef	struct fd_set {
	fd_mask	fds_bits[(4096 + (sizeof(fd_mask) * 8) - 1) / (sizeof(fd_mask) * 8)];
} fd_set;






















extern "C" {


struct timeval;
extern int select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
extern void *memset(void *, int, size_t);


}






#line 563 "/usr/include/sys/types.h"









typedef struct __sched_fifo_param {
	int	__prio;
} sched_fifo_param_t;

typedef struct __sched_fcfs_param {
	int	__prio;
} sched_fcfs_param_t;

typedef struct __sched_other_param {
	int	__prio;
} sched_other_param_t;

typedef struct __sched_ts_param {
	int	__prio;
} sched_ts_param_t;

union __sched_union {
	sched_fifo_param_t	__sched_fifo;
	sched_fcfs_param_t	__sched_fcfs;
	sched_other_param_t	__sched_other;
	sched_ts_param_t	__sched_ts;
	long			__policy_params[1];	
};

struct __sched_param {
	int			__sched_priority;
	union __sched_union	__sched_other_stuff;
};

typedef struct {
	int	__pt_attr_status;	
	size_t	__pt_attr_stacksize;	
	void	*__pt_attr_stackaddr;	
	int	__pt_attr_detachstate;	
	int	__pt_attr_contentionscope;
	int	__pt_attr_inheritsched;	
	int	__pt_attr_schedpolicy;	
	struct __sched_param	__pt_attr_sched_param;
	int	__pt_attr_tlflags;	
} pthread_attr_t;

typedef struct {
	int	__pt_condattr_status;	
	int	__pt_condattr_pshared;	
} pthread_condattr_t;

typedef struct {
	int	__pt_mutexattr_status;	
	int	__pt_mutexattr_pshared;	
	int	__pt_mutexattr_type;
} pthread_mutexattr_t;

typedef struct {
	int	__pt_rwlockattr_status;	
	int	__pt_rwlockattr_pshared;	
} pthread_rwlockattr_t;

typedef struct __thrq_elt thrq_elt_t;

struct __thrq_elt {
	thrq_elt_t	*__thrq_next;
	thrq_elt_t	*__thrq_prev;
};

typedef volatile unsigned char _simplelock_t;

typedef volatile struct __lwp_mutex {
	char		__wanted;
	_simplelock_t	__lock;
} lwp_mutex_t;

typedef volatile struct __mutex {
	lwp_mutex_t		__m_lmutex;
	lwp_mutex_t		__m_sync_lock;
	int			__m_type;
	thrq_elt_t		__m_sleepq;
	int			__filler[2];
} mutex_t;



 
typedef volatile struct __rmutex {
	mutex_t		__rm_mutex;
	pid_t		__rm_pid;
	thread_t	__rm_owner;
	int		__rm_depth;
	long		__filler;
} rmutex_t;

typedef volatile struct __pthread_mutex {
	mutex_t			__pt_mutex_mutex;
	pid_t			__pt_mutex_pid;
	thread_t		__pt_mutex_owner;
	int			__pt_mutex_depth;
	pthread_mutexattr_t	__pt_mutex_attr;
} pthread_mutex_t;

typedef volatile struct __lwp_cond {
	char			__wanted;
} lwp_cond_t;

typedef volatile struct __cond {
	lwp_cond_t		__c_lcond;
	lwp_mutex_t		__c_sync_lock;
	int			__c_type;
	thrq_elt_t		__c_syncq;
} cond_t;

typedef volatile struct __sema {
	mutex_t		__s_mutex;
	cond_t		__s_cond;
	short		__s_count;
	short		__s_wakecnt;
	int		__s_type;
} sema_t, sem_t;

typedef volatile struct __pthread_cond {
	cond_t			__pt_cond_cond;
	pthread_condattr_t	__pt_cond_attr;
} pthread_cond_t;

typedef volatile struct __rwcv rwcv_t;

struct __rwcv {
	cond_t		__rwcv_cond;
	rwcv_t		*__rwcv_next;
	char		__rwcv_rw;
	char		__rwcv_wakeup;
	short		__rwcv_readerwanted;
};

struct __rwlock {
	mutex_t		__rw_mutex;
	lwp_cond_t	__rw_lwpcond;
	int		__rw_type;
	short		__rw_readers;
	char		__rw_writer;
	char		__rw_wrwakeup;
	short		__rw_writerwanted;
	short		__rw_rdwakecnt;
	rwcv_t		*__rw_cvqhead;
	rwcv_t		*__rw_cvqtail;
	int		__pad[4];
};

typedef struct {
	struct __rwlock		__pt_rwlock_rwlock;
	pthread_rwlockattr_t	__pt_rwlock_attr;
}  pthread_rwlock_t;

typedef unsigned int		thread_key_t;

typedef thread_key_t		pthread_key_t;

typedef struct {
	int		__pt_once_initialized;
	int		__pt_once_init_in_progress;
	mutex_t		__pt_once_mutex;
	cond_t		__pt_once_cond;
} pthread_once_t;

typedef unsigned long	clusternode_t;	 





 







typedef	unsigned long	mask_t;		 




typedef	mask_t		priv_t;		 


#line 22 "/usr/include/stdio.h"
typedef long		fpos32_t;
typedef long long	fpos64_t;



typedef long		fpos_t;
#line 35 "/usr/include/stdio.h"
















































typedef struct _FILE_
{
	int		__cnt;		 
	unsigned char	*__ptr;		 
	unsigned char	*__base;	 
	unsigned char	__flag;		 
	unsigned char	__file;		 
	unsigned char	__buf[2];	 
} FILE;

#line 107 "/usr/include/stdio.h"











extern "C" {


extern FILE	__iob[];

extern int	remove(const char *);
extern int	rename(const char *, const char *);
extern FILE	*tmpfile(void);
extern char	*tmpnam(char *);
extern int	fclose(FILE *);
extern int	fflush(FILE *);
extern FILE	*fopen(const char *, const char *);
extern FILE	*freopen(const char *, const char *, FILE *);
extern void	setbuf(FILE *, char *);
extern int	setvbuf(FILE *, char *, int, size_t);
		 
extern int	fprintf(FILE *, const char *, ...);
		 
extern int	fscanf(FILE *, const char *, ...);
		 
extern int	printf(const char *, ...);
		 
extern int	scanf(const char *, ...);
		 
extern int	sprintf(char *, const char *, ...);
		 
extern int	sscanf(const char *, const char *, ...);
extern int	vfprintf(FILE *, const char *, void *);
extern int	vprintf(const char *, void *);
extern int	vsprintf(char *, const char *, void *);
extern int	fgetc(FILE *);
extern char	*fgets(char *, int, FILE *);
extern int	fputc(int, FILE *);
extern int	fputs(const char *, FILE *);
extern int	getc(FILE *);
extern int	getchar(void);
extern char	*gets(char *);
extern int	putc(int, FILE *);
extern int	putchar(int);
extern int	puts(const char *);
extern int	ungetc(int, FILE *);
extern size_t	fread(void *, size_t, size_t, FILE *);
extern size_t	fwrite(const void *, size_t, size_t, FILE *);
extern int	fgetpos(FILE *, fpos_t *);
extern int	fseek(FILE *, long, int);
extern int	fsetpos(FILE *, const fpos_t *);
extern long	ftell(FILE *);
extern void	rewind(FILE *);
extern void	clearerr(FILE *);
extern int	feof(FILE *);
extern int	ferror(FILE *);
extern void	perror(const char *);

extern int	__filbuf(FILE *);
extern int	__flsbuf(int, FILE *);




inline int getc(FILE *__1)
	{ return --__1->__cnt < 0 ? __filbuf(__1) : *__1->__ptr++; }
inline int putc(int __1, FILE *__2)
	{return --__2->__cnt < 0 ? __flsbuf(__1, __2) : (*__2->__ptr++ = __1);}


inline int getchar(){ return getc((&__iob[0])); }
inline int putchar(int __1){ return putc(__1, (&__iob[1])); }

inline int feof(FILE *__1){ return __1->__flag & 0020; }
inline int ferror(FILE *__1){ return __1->__flag & 0040; }

#line 206 "/usr/include/stdio.h"



extern char	*ctermid(char *);
extern FILE	*fdopen(int, const char *);
extern int	fileno(FILE *);




extern FILE	*popen(const char *, const char *);
extern char	*cuserid(char *);
extern char	*tempnam(const char *, const char *);
extern char	*optarg;
extern int	optind, opterr, optopt;
extern int	getopt(int, char *const *, const char *);
extern int	getw(FILE *);
extern int	putw(int, FILE *);
extern int	pclose(FILE *);







extern int	getc_unlocked(FILE *);
extern int	getchar_unlocked(void);
extern int	putc_unlocked(int, FILE *);
extern int	putchar_unlocked(int);



inline int getc_unlocked(FILE *__1)
	{ return --__1->__cnt < 0 ? __filbuf(__1) : *__1->__ptr++; }
inline int putc_unlocked(int __1, FILE *__2)
	{return --__2->__cnt < 0 ? __flsbuf(__1, __2) : (*__2->__ptr++ = __1);}

inline int getchar_unlocked(){ return getc_unlocked((&__iob[0])); }
inline int putchar_unlocked(int __1){ return putc_unlocked(__1, (&__iob[1])); }

#line 257 "/usr/include/stdio.h"

extern void	flockfile(FILE *);
extern int	ftrylockfile(FILE *);
extern void	funlockfile(FILE *);








extern int	fseeko(FILE *, n_off_t, int);
extern n_off_t	ftello(FILE *);

extern int	fgetpos32(FILE *, fpos32_t *);
extern FILE	*fopen32(const char *, const char *);
extern FILE	*freopen32(const char *, const char *, FILE *);
extern int	fseeko32(FILE *, off32_t, int);
extern int	fsetpos32(FILE *, const fpos32_t *);
extern off32_t	ftello32(FILE *);
extern FILE	*tmpfile32(void);

extern int	fgetpos64(FILE *, fpos64_t *);
extern FILE	*fopen64(const char *, const char *);
extern FILE	*freopen64(const char *, const char *, FILE *);
extern int	fseeko64(FILE *, off64_t, int);
extern int	fsetpos64(FILE *, const fpos64_t *);
extern off64_t	ftello64(FILE *);
extern FILE	*tmpfile64(void);

#line 323 "/usr/include/stdio.h"






#line 335 "/usr/include/stdio.h"



typedef long	wint_t;


extern int	system(const char *);
extern int	fwide(FILE *, int);
extern wint_t	fgetwc(FILE *);
extern wchar_t	*fgetws(wchar_t *, int, FILE *);
extern wint_t	fputwc(wchar_t, FILE *);
extern int	fputws(const wchar_t *, FILE *);
extern wint_t	getwc(FILE *);
extern wint_t	getwchar(void);
extern wint_t	putwc(wchar_t, FILE *);
extern wint_t	putwchar(wchar_t);
extern wint_t	ungetwc(wint_t, FILE *);
		 
extern int	fwprintf(FILE *, const wchar_t *, ...);
		 
extern int	fwscanf(FILE *, const wchar_t *, ...);
		 
extern int	wprintf(const wchar_t *, ...);
		 
extern int	wscanf(const wchar_t *, ...);
		 
extern int	swprintf(wchar_t *, size_t, const wchar_t *, ...);
		 
extern int	swscanf(const wchar_t *, const wchar_t *, ...);
extern int	vfwprintf(FILE *, const wchar_t *, void *);
extern int	vfwscanf(FILE *, const wchar_t *, void *);
extern int	vwprintf(const wchar_t *, void *);
extern int	vwscanf(const wchar_t *, void *);
extern int	vswprintf(wchar_t *, size_t, const wchar_t *, void *);
extern int	vswscanf(const wchar_t *, const wchar_t *, void *);
extern void	funflush(FILE *);
		 
extern int	asprintf(char **, const char *, ...);
		 
extern int	vasprintf(char **, const char *, void *);
		 
extern int	fsprintf(char *, size_t,
			int (*)(void *, const char *, size_t), void *,
			const char *, ...);
		 
extern int	vfsprintf(char *, size_t,
			int (*)(void *, const char *, size_t), void *,
			const char *, void *);
		 
extern int	snprintf(char *, size_t, const char *, ...);
		 
extern int	_xsnprintf(char *, size_t, const char *, ...);  
extern int	vsnprintf(char *, size_t, const char *, void *);
extern int	_xvsnprintf(char *, size_t, const char *, void *);  
extern int	vfscanf(FILE *, const char *, void *);
extern int	vscanf(const char *, void *);
extern int	vsscanf(const char *, const char *, void *);




}
#line 1 "/usr/include/CC/cstdio"

#line 28 "/usr/include/CC/cstdio"




 
#line 399 "/usr/include/stdio.h"



#line 5 "/usr/include/CC/cstdio"
#line 1 "/usr/include/CC/yvals.h"
 



		 
#line 18 "/usr/include/CC/yvals.h"

		 



namespace std {
		 

typedef bool _Bool;


		 
#line 38 "/usr/include/CC/yvals.h"

		 





#line 55 "/usr/include/CC/yvals.h"








		 
#line 71 "/usr/include/CC/yvals.h"

		 
typedef int _Mbstatet;

		 
#line 86 "/usr/include/CC/yvals.h"

		




		
class _Lockit
	{	
public:
	explicit _Lockit(int = 0);	

	~_Lockit();	
private:
	int _which_lock;	
	};


		 



}





 
#line 6 "/usr/include/CC/cstdio"


namespace std {
using ::size_t; using ::fpos_t; using ::FILE;
using ::clearerr; using ::fclose; using ::feof;
using ::ferror; using ::fflush; using ::fgetc;
using ::fgetpos; using ::fgets; using ::fopen;
using ::fprintf; using ::fputc; using ::fputs;
using ::fread; using ::freopen; using ::fscanf;
using ::fseek; using ::fsetpos; using ::ftell;
using ::fwrite; using ::getc;
using ::getchar; using ::gets;
using ::perror; using ::putc; using ::putchar;
using ::printf; using ::puts; using ::remove;
using ::rename; using ::rewind; using ::scanf;
using ::setbuf; using ::setvbuf; using ::sprintf;
using ::sscanf; using ::tmpfile; using ::tmpnam;
using ::ungetc; using ::vfprintf; using ::vprintf;
using ::vsprintf;

}	





 
#line 5 "/usr/include/CC/iosfwd"
#line 1 "/usr/include/CC/cstring"

#line 1 "/usr/include/string.h"










  



#ident	"@(#)unixsrc:usr/src/i386/head/string.h /main/1"











extern "C" {


extern void	*memcpy(void *, const void *, size_t);
extern void	*memccpy(void *, const void *, int, size_t);
extern void	*memmove(void *, const void *, size_t);
extern void	*memset(void *, int, size_t);

extern char	*strcpy(char *, const char *);
extern char	*strdup(const char *);
extern char	*strncpy(char *, const char *, size_t);
extern char	*strcat(char *, const char *);
extern char	*strncat(char *, const char *, size_t);
extern char	*strtok(char *, const char *);
extern char	*strtok_r(char *, const char *, char **);
extern char	*strerror(int);
extern char	*strlist(char *, const char *, ...);
extern char	*strsignal(int);

extern int	memcmp(const void *, const void *, size_t);
extern int	strcmp(const char *, const char *);
extern int	strcoll(const char *, const char *);
extern int	strncmp(const char *, const char *, size_t);

extern size_t	strxfrm(char *, const char *, size_t);
extern size_t	strcspn(const char *, const char *);
extern size_t	strspn(const char *, const char *);
extern size_t	strlen(const char *);

extern char	*strcadd(char *, const char *);
extern char	*strccpy(char *, const char *);
extern char	*streadd(char *, const char *, const char *);
extern char	*strecpy(char *, const char *, const char *);
extern int	strfind(const char *, const char *);
extern char	*strtrns(const char *, const char *, const char *, char *);

extern size_t	strlcat(char *, const char *, size_t);
extern size_t	strlcpy(char *, const char *, size_t);



extern int	ffs(int);




const void	*memchr(const void *, int, size_t);
const char	*strchr(const char *, int);
const char	*strpbrk(const char *, const char *);
const char	*strrchr(const char *, int);
const char	*strrspn(const char *, const char *);
const char	*strstr(const char *, const char *);

}  

extern "C++" {
inline void *memchr(void *__1, int __2, size_t __3)
	{ return (void *)memchr((const void *)__1, __2, __3); }
inline char *strchr(char *__1, int __2)
	{ return (char *)strchr((const char *)__1, __2); }
inline char *strpbrk(char *__1, const char *__2)
	{ return (char *)strpbrk((const char *)__1, __2); }
inline char *strrchr(char *__1, int __2)
	{ return (char *)strrchr((const char *)__1, __2); }
inline char *strrspn(char *__1, const char *__2)
	{ return (char *)strrspn((const char *)__1, __2); }
inline char *strstr(char *__1, const char *__2)
	{ return (char *)strstr((const char *)__1, __2); }
}

#line 1 "/usr/include/CC/cstring"

#line 21 "/usr/include/CC/cstring"




 
#line 99 "/usr/include/string.h"


#line 111 "/usr/include/string.h"

#line 5 "/usr/include/CC/cstring"



namespace std {
using ::size_t; using ::memchr; using ::memcmp;
using ::memcpy; using ::memmove; using ::memset;
using ::strcat; using ::strchr; using ::strcmp;
using ::strcoll; using ::strcpy; using ::strcspn;
using ::strerror; using ::strlen; using ::strncat;
using ::strncmp; using ::strncpy; using ::strpbrk;
using ::strrchr; using ::strspn; using ::strstr;
using ::strtok; using ::strxfrm;


}	





 
#line 6 "/usr/include/CC/iosfwd"
#line 1 "/usr/include/CC/cwchar"

#line 1 "/usr/include/wchar.h"










  



#ident	"@(#)unixsrc:usr/src/common/head/wchar.h /main/3"

#line 23 "/usr/include/wchar.h"



typedef unsigned long	wuchar_t;














typedef struct
{
	unsigned char	__rule[4];
	wchar_t		__mbwc;
	wchar_t		__mbst;
} mbstate_t;


struct _FILE_;		 
struct tm;		 









#line 71 "/usr/include/wchar.h"

#line 84 "/usr/include/wchar.h"


extern "C" {


extern wint_t	fgetwc(struct _FILE_ *);
extern wchar_t	*fgetws(wchar_t *, int, struct _FILE_ *);
extern wint_t	fputwc(wchar_t, struct _FILE_ *);
extern int	fputws(const wchar_t *, struct _FILE_ *);
extern wint_t	getwc(struct _FILE_ *);
extern wint_t	getwchar(void);
extern wint_t	putwc(wchar_t, struct _FILE_ *);
extern wint_t	putwchar(wchar_t);
extern wint_t	ungetwc(wint_t, struct _FILE_ *);

extern wchar_t	*wcscat(wchar_t *, const wchar_t *);
extern int	wcscmp(const wchar_t *, const wchar_t *);
extern int	wcscoll(const wchar_t *, const wchar_t *);
extern size_t	wcsxfrm(wchar_t *, const wchar_t *, size_t);
extern wchar_t	*wcscpy(wchar_t *, const wchar_t *);
extern size_t	wcscspn(const wchar_t *, const wchar_t *);
extern size_t	wcslen(const wchar_t *);
extern wchar_t	*wcsncat(wchar_t *, const wchar_t *, size_t);
extern int	wcsncmp(const wchar_t *, const wchar_t *, size_t);
extern wchar_t	*wcsncpy(wchar_t *, const wchar_t *, size_t);
extern size_t	wcsspn(const wchar_t *, const wchar_t *);
extern wchar_t	*_wcstok(wchar_t *, const wchar_t *, wchar_t **);

extern double	wcstod(const wchar_t *, wchar_t **);
	 
extern float	wcstof(const wchar_t *, wchar_t **);
extern long	wcstol(const wchar_t *, wchar_t **, int);
long double	wcstold(const wchar_t *, wchar_t **);
long long	wcstoll(const wchar_t *, wchar_t **, int);
unsigned long	wcstoul(const wchar_t *, wchar_t **, int);
unsigned long long wcstoull(const wchar_t *, wchar_t **, int);
extern int	wcswidth(const wchar_t *, size_t);

#line 153 "/usr/include/wchar.h"

extern size_t	wcsftime(wchar_t *, size_t, const wchar_t *, const struct tm *);

extern wchar_t	*wcstok(wchar_t *, const wchar_t *, wchar_t **);

extern int	fwide(struct _FILE_ *, int);
		 
extern int	fwprintf(struct _FILE_ *, const wchar_t *, ...);
		 
extern int	fwscanf(struct _FILE_ *, const wchar_t *, ...);
		 
extern int	wprintf(const wchar_t *, ...);
		 
extern int	wscanf(const wchar_t *, ...);
		 
extern int	swprintf(wchar_t *, size_t, const wchar_t *, ...);
		 
extern int	swscanf(const wchar_t *, const wchar_t *, ...);
extern int	vfwprintf(struct _FILE_ *, const wchar_t *, void *);
extern int	vwprintf(const wchar_t *, void *);
extern int	vswprintf(wchar_t *, size_t, const wchar_t *, void *);

extern wint_t	btowc(int);
extern int	wctob(wint_t);
extern size_t	mbrlen(const char *, size_t, mbstate_t *);
extern size_t	mbrtowc(wchar_t *, const char *, size_t, mbstate_t *);
extern size_t	wcrtomb(char *, wchar_t, mbstate_t *);
extern size_t	mbsrtowcs(wchar_t *, const char **, size_t, mbstate_t *);
extern size_t	wcsrtombs(char *, const wchar_t **, size_t, mbstate_t *);
extern int	mbsinit(const mbstate_t *);


inline size_t mbrlen(const char *__1, size_t __2, mbstate_t *__3)
	{ return mbrtowc(0, __1, __2, __3); }




extern int	wmemcmp(const wchar_t *, const wchar_t *, size_t);
extern wchar_t	*wmemcpy(wchar_t *, const wchar_t *, size_t);
extern wchar_t	*wmemmove(wchar_t *, const wchar_t *, size_t);
extern wchar_t	*wmemset(wchar_t *, wchar_t, size_t);




extern int	mbswidth(const char *, size_t);
extern int	wcwidth(wchar_t);
extern int	vfwscanf(struct _FILE_ *, const wchar_t *, void *);
extern int	vwscanf(const wchar_t *, void *);
extern int	vswscanf(const wchar_t *, const wchar_t *, void *);




const wchar_t	*wcschr(const wchar_t *, wchar_t);
const wchar_t	*wcspbrk(const wchar_t *, const wchar_t *);
const wchar_t	*wcsrchr(const wchar_t *, wchar_t);
const wchar_t	*wcsstr(const wchar_t *, const wchar_t *);
const wchar_t	*wcswcs(const wchar_t *, const wchar_t *);  
const wchar_t	*wmemchr(const wchar_t *, wchar_t, size_t);

}  

extern "C++" {
inline wchar_t *wcschr(wchar_t *__1, wchar_t __2)
	{ return (wchar_t *)wcschr((const wchar_t *)__1, __2); }
inline wchar_t *wcspbrk(wchar_t *__1, const wchar_t *__2)
	{ return (wchar_t *)wcspbrk((const wchar_t *)__1, __2); }
inline wchar_t *wcsrchr(wchar_t *__1, wchar_t __2)
	{ return (wchar_t *)wcsrchr((const wchar_t *)__1, __2); }
inline wchar_t *wcsstr(wchar_t *__1, const wchar_t *__2)
	{ return (wchar_t *)wcsstr((const wchar_t *)__1, __2); }
inline wchar_t *wcswcs(wchar_t *__1, const wchar_t *__2)  
	{ return (wchar_t *)wcswcs((const wchar_t *)__1, __2); }  
inline wchar_t *wmemchr(wchar_t *__1, wchar_t __2, size_t __3)
	{ return (wchar_t *)wmemchr((const wchar_t *)__1, __2, __3); }
}

#line 1 "/usr/include/CC/cwchar"

#line 30 "/usr/include/CC/cwchar"




 
#line 234 "/usr/include/wchar.h"


#line 249 "/usr/include/wchar.h"

#line 5 "/usr/include/CC/cwchar"



namespace std {
using ::mbstate_t; using ::size_t; using ::tm; using ::wint_t;
using ::btowc; using ::fgetwc; using ::fgetws; using ::fputwc;
using ::fputws; using ::fwide; using ::fwprintf;
using ::fwscanf; using ::getwc; using ::getwchar;
using ::mbrlen; using ::mbrtowc; using ::mbsrtowcs;
using ::mbsinit; using ::putwc; using ::putwchar;
using ::swprintf; using ::swscanf; using ::ungetwc;
using ::vfwprintf; using ::vswprintf; using ::vwprintf;
using ::wcrtomb; using ::wprintf; using ::wscanf;
using ::wcsrtombs; using ::wcstol; using ::wcscat;
using ::wcschr; using ::wcscmp; using ::wcscoll;
using ::wcscpy; using ::wcscspn; using ::wcslen;
using ::wcsncat; using ::wcsncmp; using ::wcsncpy;
using ::wcspbrk; using ::wcsrchr; using ::wcsspn;
using ::wcstod; using ::wcstoul; using ::wcsstr;
using ::wcstok; using ::wcsxfrm; using ::wctob;
using ::wmemchr; using ::wmemcmp; using ::wmemcpy;
using ::wmemmove; using ::wmemset; using ::wcsftime;

}	





 
#line 7 "/usr/include/CC/iosfwd"
#line 1 "/usr/include/CC/xstddef"

#line 1 "/usr/include/CC/cstddef"







namespace std {
using ::ptrdiff_t; using ::size_t;

}	





 
#line 8 "/usr/include/CC/xstddef"

namespace std {

		












		










		


#line 66 "/usr/include/CC/xstddef"

		









		
enum _Uninitialized
	{	
	_Noinit};

		
void _Nomemory();




extern "C" {
typedef void _Atexit_fun();
	}	




}	





 
#line 8 "/usr/include/CC/iosfwd"

namespace std {

		
typedef long streamoff;
typedef int streamsize;
extern fpos_t _Fpz;
extern const streamoff _BADOFF;

		
template<class _Statetype>
	class fpos
	{	
	typedef fpos<_Statetype> _Myt;

public:
	fpos(streamoff _Off = 0)
		: _Myoff(_Off), _Fpos(_Fpz), _Mystate(_Stz)
		{}	

	fpos(_Statetype _State, fpos_t _Fileposition)
		: _Myoff(0), _Fpos(_Fileposition), _Mystate(_State)
		{}	

	_Statetype state() const
		{	
		return (_Mystate); }

	void state(_Statetype _State)
		{	
		_Mystate = _State; }

	fpos_t seekpos() const
		{	
		return (_Fpos); }

	operator streamoff() const
		{	
		return (_Myoff + ((long)(_Fpos))); }

	streamoff operator-(const _Myt& _Right) const
		{	
		return ((streamoff)*this - (streamoff)_Right); }

	_Myt& operator+=(streamoff _Off)
		{	
		_Myoff += _Off;
		return (*this); }

	_Myt& operator-=(streamoff _Off)
		{	
		_Myoff -= _Off;
		return (*this); }

	_Myt operator+(streamoff _Off) const
		{	
		_Myt _Tmp = *this;
		return (_Tmp += _Off); }

	_Myt operator-(streamoff _Off) const
		{	
		_Myt _Tmp = *this;
		return (_Tmp -= _Off); }

	bool operator==(const _Myt& _Right) const
		{	
		return ((streamoff)*this == (streamoff)_Right); }

	bool operator!=(const _Myt& _Right) const
		{	
		return (!(*this == _Right)); }

private:
	static _Statetype _Stz;	
	streamoff _Myoff;	
	fpos_t _Fpos;	
	_Statetype _Mystate;	
	};

	
template<class _Statetype>
	_Statetype fpos<_Statetype>::_Stz;

typedef fpos<mbstate_t> streampos;
typedef streampos wstreampos;

		
template<class _Elem>
	struct char_traits
	{	
	typedef _Elem char_type;
	typedef _Elem int_type;
	typedef streampos pos_type;
	typedef streamoff off_type;
	typedef mbstate_t state_type;

	static void assign(_Elem& _Left, const _Elem& _Right)
		{	
		_Left = _Right; }

	static bool eq(const _Elem& _Left, const _Elem& _Right)
		{	
		return (_Left == _Right); }

	static bool lt(const _Elem& _Left, const _Elem& _Right)
		{	
		return (_Left < _Right); }

	static int compare(const _Elem *_First1, const _Elem *_First2,
		size_t _Size)
		{	
		for (size_t _Count = 0; _Count < _Size;
			++_Count, ++_First1, ++_First2)
			if (!eq(*_First1, *_First2))
				return (lt(*_First1, *_First2) ? -1 : +1);
		return (0); }

	static size_t length(const _Elem *_First)
		{	
		size_t _Size;
		for (_Size = 0; !eq(*_First, _Elem()); ++_First)
			++_Size;
		return (_Size); }

	static _Elem *copy(_Elem *_First1, const _Elem *_First2,
		size_t _Size)
		{	
		_Elem *_Next = _First1;
		for (; 0 < _Size; --_Size, ++_Next, ++_First2)
			assign(*_Next, *_First2);
		return (_First1); }

	static const _Elem *find(const _Elem *_First, size_t _Size,
		const _Elem& _Char)
		{	
		for (; 0 < _Size; --_Size, ++_First)
			if (eq(*_First, _Char))
				return (_First);
		return (0); }

	static _Elem *move(_Elem *_First1, const _Elem *_First2,
		size_t _Size)
		{	
		_Elem *_Next = _First1;
		if (_First2 < _Next && _Next < _First2 + _Size)
			for (_Next += _Size, _First2 += _Size; 0 < _Size; --_Size)
				assign(*--_Next, *--_First2);
		else
			for (; 0 < _Size; --_Size, ++_Next, ++_First2)
				assign(*_Next, *_First2);
		return (_First1); }

	static _Elem *assign(_Elem *_First, size_t _Size, _Elem _Char)
		{	
		_Elem *_Next = _First;
		for (; 0 < _Size; --_Size, ++_Next)
			assign(*_Next, _Char);
		return (_First); }

	static _Elem to_char_type(const int_type& _Meta)
		{	
		return (_Meta); }

	static int_type to_int_type(const _Elem& _Char)
		{	
		return (_Char); }

	static bool eq_int_type(const int_type& _Left,
		const int_type& _Right)
		{	
		return (_Left == _Right); }

	static int_type eof()
		{	
		return ((int_type)(-1)); }

	static int_type not_eof(const int_type& _Meta)
		{	
		return (_Meta != eof() ? _Meta : !eof()); }
	};

		
template<> struct char_traits<wchar_t>
	{	
	typedef wchar_t _Elem;
	typedef _Elem char_type;	
	typedef wint_t int_type;
	typedef streampos pos_type;
	typedef streamoff off_type;
	typedef mbstate_t state_type;

	static void assign(_Elem& _Left, const _Elem& _Right)
		{	
		_Left = _Right; }

	static bool eq(const _Elem& _Left, const _Elem& _Right)
		{	
		return (_Left == _Right); }

	static bool lt(const _Elem& _Left, const _Elem& _Right)
		{	
		return (_Left < _Right); }

	static int compare(const _Elem *_First1, const _Elem *_First2,
		size_t _Size)
		{	
		return (wmemcmp(_First1, _First2, _Size)); }

	static size_t length(const _Elem *_First)
		{	
		return (wcslen(_First)); }

	static _Elem *copy(_Elem *_First1, const _Elem *_First2,
		size_t _Size)
		{	
		return (wmemcpy(_First1, _First2, _Size)); }

	static const _Elem *find(const _Elem *_First, size_t _Size,
		const _Elem& _Char)
		{	
		return ((const _Elem *)wmemchr(_First, _Char, _Size)); }

	static _Elem *move(_Elem *_First1, const _Elem *_First2,
		size_t _Size)
		{	
		return (wmemmove(_First1, _First2, _Size)); }

	static _Elem *assign(_Elem *_First, size_t _Size, _Elem _Char)
		{	
		return (wmemset(_First, _Char, _Size)); }

	static _Elem to_char_type(const int_type& _Meta)
		{	
		return (_Meta); }

	static int_type to_int_type(const _Elem& _Char)
		{	
		return (_Char); }

	static bool eq_int_type(const int_type& _Left,
		const int_type& _Right)
		{	
		return (_Left == _Right); }

	static int_type eof()
		{	
		return ((-1)); }

	static int_type not_eof(const int_type& _Meta)
		{	
		return (_Meta != eof() ? _Meta : !eof()); }
	};

		
template<> struct char_traits<char>
	{	
	typedef char _Elem;
	typedef _Elem char_type;
	typedef int int_type;
	typedef streampos pos_type;
	typedef streamoff off_type;
	typedef mbstate_t state_type;

	static void assign(_Elem& _Left, const _Elem& _Right)
		{	
		_Left = _Right; }

	static bool eq(const _Elem& _Left, const _Elem& _Right)
		{	
		return (_Left == _Right); }

	static bool lt(const _Elem& _Left, const _Elem& _Right)
		{	
		return (_Left < _Right); }

	static int compare(const _Elem *_First1, const _Elem *_First2,
		size_t _Size)
		{	
		return (memcmp(_First1, _First2, _Size)); }

	static size_t length(const _Elem *_First)
		{	
		return (strlen(_First)); }

	static _Elem *copy(_Elem *_First1, const _Elem *_First2,
		size_t _Size)
		{	
		return ((_Elem *)memcpy(_First1, _First2, _Size)); }

	static const _Elem *find(const _Elem *_First, size_t _Size,
		const _Elem& _Char)
		{	
		return ((const _Elem *)memchr(_First, _Char, _Size)); }

	static _Elem *move(_Elem *_First1, const _Elem *_First2,
		size_t _Size)
		{	
		return ((_Elem *)memmove(_First1, _First2, _Size)); }

	static _Elem *assign(_Elem *_First, size_t _Size, _Elem _Char)
		{	
		return ((_Elem *)memset(_First, _Char, _Size)); }

	static _Elem to_char_type(const int_type& _Meta)
		{	
		return ((_Elem)_Meta); }

	static int_type to_int_type(const _Elem& _Char)
		{	
		return ((unsigned char)_Char); }

	static bool eq_int_type(const int_type& _Left,
		const int_type& _Right)
		{	
		return (_Left == _Right); }

	static int_type eof()
		{	
		return ((-1)); }

	static int_type not_eof(const int_type& _Meta)
		{	
		return (_Meta != eof() ? _Meta : !eof()); }
	};

		
template<class _Ty>
	class allocator;
class ios_base;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_ios;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class istreambuf_iterator;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class ostreambuf_iterator;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_streambuf;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_istream;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_ostream;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_iostream;
template<class _Elem,
	class _Traits = char_traits<_Elem>,
	class _Alloc = allocator<_Elem> >
	class basic_stringbuf;
template<class _Elem,
	class _Traits = char_traits<_Elem>,
	class _Alloc = allocator<_Elem> >
	class basic_istringstream;
template<class _Elem,
	class _Traits = char_traits<_Elem>,
	class _Alloc = allocator<_Elem> >
	class basic_ostringstream;
template<class _Elem,
	class _Traits = char_traits<_Elem>,
	class _Alloc = allocator<_Elem> >
	class basic_stringstream;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_filebuf;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_ifstream;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_ofstream;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_fstream;

		
typedef basic_ios<char, char_traits<char> > ios;
typedef basic_streambuf<char, char_traits<char> > streambuf;
typedef basic_istream<char, char_traits<char> > istream;
typedef basic_ostream<char, char_traits<char> > ostream;
typedef basic_iostream<char, char_traits<char> > iostream;
typedef basic_stringbuf<char, char_traits<char>,
	allocator<char> > stringbuf;
typedef basic_istringstream<char, char_traits<char>,
	allocator<char> > istringstream;
typedef basic_ostringstream<char, char_traits<char>,
	allocator<char> > ostringstream;
typedef basic_stringstream<char, char_traits<char>,
	allocator<char> > stringstream;
typedef basic_filebuf<char, char_traits<char> > filebuf;
typedef basic_ifstream<char, char_traits<char> > ifstream;
typedef basic_ofstream<char, char_traits<char> > ofstream;
typedef basic_fstream<char, char_traits<char> > fstream;

		
typedef basic_ios<wchar_t, char_traits<wchar_t> > wios;
typedef basic_streambuf<wchar_t, char_traits<wchar_t> >
	wstreambuf;
typedef basic_istream<wchar_t, char_traits<wchar_t> > wistream;
typedef basic_ostream<wchar_t, char_traits<wchar_t> > wostream;
typedef basic_iostream<wchar_t, char_traits<wchar_t> > wiostream;
typedef basic_stringbuf<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wstringbuf;
typedef basic_istringstream<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wistringstream;
typedef basic_ostringstream<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wostringstream;
typedef basic_stringstream<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wstringstream;
typedef basic_filebuf<wchar_t, char_traits<wchar_t> > wfilebuf;
typedef basic_ifstream<wchar_t, char_traits<wchar_t> > wifstream;
typedef basic_ofstream<wchar_t, char_traits<wchar_t> > wofstream;
typedef basic_fstream<wchar_t, char_traits<wchar_t> > wfstream;


}	





 
#line 5 "/usr/include/CC/utility"


namespace std {
		
template<class _Ty> inline
	void swap(_Ty& _Left, _Ty& _Right)
	{	
	_Ty _Tmp = _Left;
	_Left = _Right, _Right = _Tmp; }

		
template<class _Ty1,
	class _Ty2> struct pair
	{	
	typedef pair<_Ty1, _Ty2> _Myt;
	typedef _Ty1 first_type;
	typedef _Ty2 second_type;

	pair()
		: first(_Ty1()), second(_Ty2())
		{}	

	pair(const _Ty1& _Val1, const _Ty2& _Val2)
		: first(_Val1), second(_Val2)
		{}	

	template<class _Other1,
		class _Other2>
		pair(const pair<_Other1, _Other2>& _Right)
		: first(_Right.first), second(_Right.second)
		{}	

	void swap(_Myt& _Right)
		{	
		std::swap(first, _Right.first);
		std::swap(second, _Right.second); }

	_Ty1 first;	
	_Ty2 second;	
	};

		
template<class _Ty1,
	class _Ty2> inline
	void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right)
	{	
	_Left.swap(_Right); }

template<class _Ty1,
	class _Ty2> inline
	bool operator==(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	
	return (_Left.first == _Right.first && _Left.second == _Right.second); }

template<class _Ty1,
	class _Ty2> inline
	bool operator!=(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	
	return (!(_Left == _Right)); }

template<class _Ty1,
	class _Ty2> inline
	bool operator<(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	
	return (_Left.first < _Right.first ||
		!(_Right.first < _Left.first) && _Left.second < _Right.second); }

template<class _Ty1,
	class _Ty2> inline
	bool operator>(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	
	return (_Right < _Left); }

template<class _Ty1,
	class _Ty2> inline
	bool operator<=(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	
	return (!(_Right < _Left)); }

template<class _Ty1,
	class _Ty2> inline
	bool operator>=(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	
	return (!(_Left < _Right)); }

template<class _Ty1,
	class _Ty2> inline
	pair<_Ty1, _Ty2> make_pair(const _Ty1& _Left, const _Ty2& _Right)
	{	
	return (pair<_Ty1, _Ty2>(_Left, _Right)); }

		
	namespace rel_ops
		{	
template<class _Ty> inline
	bool operator!=(const _Ty& _Left, const _Ty& _Right)
	{	
	return (!(_Left == _Right)); }

template<class _Ty> inline
	bool operator>(const _Ty& _Left, const _Ty& _Right)
	{	
	return (_Right < _Left); }

template<class _Ty> inline
	bool operator<=(const _Ty& _Left, const _Ty& _Right)
	{	
	return (!(_Right < _Left)); }

template<class _Ty> inline
	bool operator>=(const _Ty& _Left, const _Ty& _Right)
	{	
	return (!(_Left < _Right)); }
	}

}	





 
















 
#line 6 "/usr/include/CC/xutility"

namespace std {



		
struct input_iterator_tag
	{};	

struct output_iterator_tag
	{};	

struct forward_iterator_tag
	: public input_iterator_tag
	{};	

struct bidirectional_iterator_tag
	: public forward_iterator_tag
	{};	

struct random_access_iterator_tag
	: public bidirectional_iterator_tag
	{};	

struct _Int_iterator_tag
	{};	

		
struct _Nonscalar_ptr_iterator_tag
	{};	
struct _Scalar_ptr_iterator_tag
	{};	

		
template<class _Category,
	class _Ty,
	class _Difference = ptrdiff_t,
	class _Pointer = _Ty *,
	class _Reference = _Ty&>
		struct iterator
	{	
	typedef _Category iterator_category;
	typedef _Ty value_type;
	typedef _Difference difference_type;
	typedef _Pointer pointer;
	typedef _Reference reference;
	};

template<class _Ty,
	class _Diff,
	class _Pointer,
	class _Reference>
	struct _Bidit
		: public iterator<bidirectional_iterator_tag, _Ty, _Diff,
			_Pointer, _Reference>
	{};	

template<class _Ty,
	class _Diff,
	class _Pointer,
	class _Reference>
	struct _Ranit
		: public iterator<random_access_iterator_tag, _Ty, _Diff,
			_Pointer, _Reference>
	{};	

struct _Outit
	: public iterator<output_iterator_tag, void, void,
		void, void>
	{};	

		
template<class _Iter>
	struct iterator_traits
	{	
	typedef typename _Iter::iterator_category iterator_category;
	typedef typename _Iter::value_type value_type;
	typedef typename _Iter::difference_type difference_type;
	typedef typename _Iter::pointer pointer;
	typedef typename _Iter::reference reference;
	};

template<class _Ty>
	struct iterator_traits<_Ty *>
	{	
	typedef random_access_iterator_tag iterator_category;
	typedef _Ty value_type;
	typedef ptrdiff_t difference_type;
	typedef _Ty *pointer;
	typedef _Ty& reference;
	};

template<class _Ty>
	struct iterator_traits<const _Ty *>
	{	
	typedef random_access_iterator_tag iterator_category;
	typedef _Ty value_type;
	typedef ptrdiff_t difference_type;
	typedef const _Ty *pointer;
	typedef const _Ty& reference;
	};

template<> struct iterator_traits<_Bool>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<char>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<signed char>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<unsigned char>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<wchar_t>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<short>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<unsigned short>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<int>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<unsigned int>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<long>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<unsigned long>
	{	
	typedef _Int_iterator_tag iterator_category;
	};


template<> struct iterator_traits<long long>
	{	
	typedef _Int_iterator_tag iterator_category;
	};

template<> struct iterator_traits<unsigned long long>
	{	
	typedef _Int_iterator_tag iterator_category;
	};


		
template<class _Iter> inline
	typename iterator_traits<_Iter>::iterator_category
		_Iter_cat(const _Iter&)
	{	
	typename iterator_traits<_Iter>::iterator_category _Cat;
	return (_Cat); }

		
template<class _T1,
	class _T2> inline
	_Nonscalar_ptr_iterator_tag _Ptr_cat(const _T1&, _T2&)
	{	
	_Nonscalar_ptr_iterator_tag _Cat;
	return (_Cat); }

template<class _Ty> inline
	_Scalar_ptr_iterator_tag _Ptr_cat(const _Ty **, _Ty **)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

		
inline _Scalar_ptr_iterator_tag _Ptr_cat(const _Bool *, _Bool *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const char *, char *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const signed char *, signed char *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const unsigned char *,
	unsigned char *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const wchar_t *, wchar_t *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const short *, short *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const unsigned short *,
	unsigned short *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const int *, int *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const unsigned int *, unsigned int *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const long *, long *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const unsigned long *,
	unsigned long *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const float *, float *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const double *, double *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const long double *, long double *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }


inline _Scalar_ptr_iterator_tag _Ptr_cat(const long long *, long long *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }

inline _Scalar_ptr_iterator_tag _Ptr_cat(const unsigned long long *, unsigned long long *)
	{	
	_Scalar_ptr_iterator_tag _Cat;
	return (_Cat); }


		
template<class _InIt> inline
	typename iterator_traits<_InIt>::difference_type
		distance(_InIt _First, _InIt _Last)
	{	
	typename iterator_traits<_InIt>::difference_type _Off = 0;
	_Distance2(_First, _Last, _Off, _Iter_cat(_First));
	return (_Off); }

template<class _InIt,
	class _Diff> inline
		void _Distance(_InIt _First, _InIt _Last, _Diff& _Off)
	{	
	_Distance2(_First, _Last, _Off, _Iter_cat(_First)); }

template<class _InIt,
	class _Diff> inline
		void _Distance2(_InIt _First, _InIt _Last, _Diff& _Off,
			input_iterator_tag)
	{	
	for (; _First != _Last; ++_First)
		++_Off; }

template<class _FwdIt,
	class _Diff> inline
		void _Distance2(_FwdIt _First, _FwdIt _Last, _Diff& _Off,
			forward_iterator_tag)
	{	
	for (; _First != _Last; ++_First)
		++_Off; }

template<class _BidIt,
	class _Diff> inline
		void _Distance2(_BidIt _First, _BidIt _Last, _Diff& _Off,
			bidirectional_iterator_tag)
	{	
	for (; _First != _Last; ++_First)
		++_Off; }

template<class _RanIt,
	class _Diff> inline
		void _Distance2(_RanIt _First, _RanIt _Last, _Diff& _Off,
			random_access_iterator_tag)
	{	
	_Off += _Last - _First; }

		
template<class _Ty,
	class _Diff,
	class _Pointer,
	class _Reference,
	class _Pointer2,
	class _Reference2>
	class _Ptrit
		: public _Ranit<_Ty, _Diff, _Pointer, _Reference>
	{	
public:
	typedef _Ptrit<_Ty, _Diff, _Pointer, _Reference,
		_Pointer2, _Reference2> _Myt;
	_Ptrit()
		{}	

	explicit _Ptrit(_Pointer _Ptr)
		: current(_Ptr)
		{}	

	_Ptrit(const _Ptrit<_Ty, _Diff, _Pointer2, _Reference2,
		_Pointer2, _Reference2>& _Iter)
		: current(_Iter.base())
		{}	

	_Pointer base() const
		{	
		return (current); }

	_Reference operator*() const
		{	
		return (*current); }

	_Pointer operator->() const
		{	
		return (&**this); }

	_Myt& operator++()
		{	
		++current;
		return (*this); }

	_Myt operator++(int)
		{	
		_Myt _Tmp = *this;
		++current;
		return (_Tmp); }

	_Myt& operator--()
		{	
		--current;
		return (*this); }

	_Myt operator--(int)
		{	
		_Myt _Tmp = *this;
		--current;
		return (_Tmp); }

	bool operator==(int _Right) const
		{	
		return (current == (_Pointer)_Right); }

	bool operator==(const _Myt& _Right) const
		{	
		return (current == _Right.current); }

	bool operator!=(const _Myt& _Right) const
		{	
		return (!(*this == _Right)); }

	_Myt& operator+=(_Diff _Off)
		{	
		current += _Off;
		return (*this); }

	_Myt operator+(_Diff _Off) const
		{	
		return (_Myt(current + _Off)); }

	_Myt& operator-=(_Diff _Off)
		{	
		current -= _Off;
		return (*this); }

	_Myt operator-(_Diff _Off) const
		{	
		return (_Myt(current - _Off)); }

	_Reference operator[](_Diff _Off) const
		{	
		return (*(*this + _Off)); }

	bool operator<(const _Myt& _Right) const
		{	
		return (current < _Right.current); }

	bool operator>(const _Myt& _Right) const
		{	
		return (_Right < *this); }

	bool operator<=(const _Myt& _Right) const
		{	
		return (!(_Right < *this)); }

	bool operator>=(const _Myt& _Right) const
		{	
		return (!(*this < _Right)); }

	_Diff operator-(const _Myt& _Right) const
		{	
		return (current - _Right.current); }

protected:
	_Pointer current;	
	};

template<class _Ty,
	class _Diff,
	class _Pointer,
	class _Reference,
	class _Pointer2,
	class _Reference2> inline
		_Ptrit<_Ty, _Diff, _Pointer, _Reference, _Pointer2, _Reference2>
			operator+(_Diff _Off,
				const _Ptrit<_Ty, _Diff, _Pointer, _Reference,
					_Pointer2, _Reference2>& _Right)
	{	
	return (_Right + _Off); }

		
template<class _RanIt>
	class reverse_iterator
		: public iterator<
			typename iterator_traits<_RanIt>::iterator_category,
			typename iterator_traits<_RanIt>::value_type,
			typename iterator_traits<_RanIt>::difference_type,
			typename iterator_traits<_RanIt>::pointer,
			typename iterator_traits<_RanIt>::reference>
	{	
public:
	typedef reverse_iterator<_RanIt> _Myt;
	typedef typename iterator_traits<_RanIt>::difference_type _Diff;
	typedef typename iterator_traits<_RanIt>::pointer _Pointer;
	typedef typename iterator_traits<_RanIt>::reference _Reference;
	typedef _RanIt iterator_type;

	reverse_iterator()
		{}	

	explicit reverse_iterator(_RanIt _First)
		: current(_First)
		{}	

	template<class _Other>
		reverse_iterator(const reverse_iterator<_Other>& _First)
		: current(_First.base())
		{}	

	_RanIt base() const
		{	
		return (current); }

	_Reference operator*() const
		{	
		_RanIt _Tmp = current;
		return (*--_Tmp); }

	_Pointer operator->() const
		{	
		return (&**this); }

	_Myt& operator++()
		{	
		--current;
		return (*this); }

	_Myt operator++(int)
		{	
		_Myt _Tmp = *this;
		--current;
		return (_Tmp); }

	_Myt& operator--()
		{	
		++current;
		return (*this); }

	_Myt operator--(int)
		{	
		_Myt _Tmp = *this;
		++current;
		return (_Tmp); }

	bool _Equal(const _Myt& _Right) const
		{	
		return (current == _Right.current); }



	_Myt& operator+=(_Diff _Off)
		{	
		current -= _Off;
		return (*this); }

	_Myt operator+(_Diff _Off) const
		{	
		return (_Myt(current - _Off)); }

	_Myt& operator-=(_Diff _Off)
		{	
		current += _Off;
		return (*this); }

	_Myt operator-(_Diff _Off) const
		{	
		return (_Myt(current + _Off)); }

	_Reference operator[](_Diff _Off) const
		{	
		return (*(*this + _Off)); }

	bool _Less(const _Myt& _Right) const
		{	
		return (_Right.current < current); }

	_Diff _Minus(const _Myt& _Right) const
		{	
		return (_Right.current - current); }

protected:
	_RanIt current;	
	};

		
template<class _RanIt,
	class _Diff> inline
	reverse_iterator<_RanIt> operator+(_Diff _Off,
		const reverse_iterator<_RanIt>& _Right)
	{	
	return (_Right + _Off); }

template<class _RanIt> inline
	typename reverse_iterator<_RanIt>::_Diff
		operator-(const reverse_iterator<_RanIt>& _Left,
		const reverse_iterator<_RanIt>& _Right)
	{	
	return (_Left._Minus(_Right)); }

template<class _RanIt> inline
	bool operator==(const reverse_iterator<_RanIt>& _Left,
		const reverse_iterator<_RanIt>& _Right)
	{	
	return (_Left._Equal(_Right)); }

template<class _RanIt> inline
	bool operator!=(const reverse_iterator<_RanIt>& _Left,
		const reverse_iterator<_RanIt>& _Right)
	{	
	return (!(_Left == _Right)); }

template<class _RanIt> inline
	bool operator<(const reverse_iterator<_RanIt>& _Left,
		const reverse_iterator<_RanIt>& _Right)
	{	
	return (_Left._Less(_Right)); }

template<class _RanIt> inline
	bool operator>(const reverse_iterator<_RanIt>& _Left,
		const reverse_iterator<_RanIt>& _Right)
	{	
	return (_Right < _Left); }

template<class _RanIt> inline
	bool operator<=(const reverse_iterator<_RanIt>& _Left,
		const reverse_iterator<_RanIt>& _Right)
	{	
	return (!(_Right < _Left)); }

template<class _RanIt> inline
	bool operator>=(const reverse_iterator<_RanIt>& _Left,
		const reverse_iterator<_RanIt>& _Right)
	{	
	return (!(_Left < _Right)); }

		
template<class _BidIt,
	class _BidIt2 = _BidIt>
	class _Revbidit
		: public iterator<
			typename iterator_traits<_BidIt>::iterator_category,
			typename iterator_traits<_BidIt>::value_type,
			typename iterator_traits<_BidIt>::difference_type,
			typename iterator_traits<_BidIt>::pointer,
			typename iterator_traits<_BidIt>::reference>
	{	
public:
	typedef _Revbidit<_BidIt, _BidIt2> _Myt;
	typedef typename iterator_traits<_BidIt>::difference_type _Diff;
	typedef typename iterator_traits<_BidIt>::pointer _Pointer;
	typedef typename iterator_traits<_BidIt>::reference _Reference;
	typedef _BidIt iterator_type;

	_Revbidit()
		{}	

	explicit _Revbidit(_BidIt _First)
		: current(_First)
		{}	

	_Revbidit(const _Revbidit<_BidIt2>& _Other)
		: current (_Other.base())
		{}	

	_BidIt base() const
		{	
		return (current); }

	_Reference operator*() const
		{	
		_BidIt _Tmp = current;
		return (*--_Tmp); }

	_Pointer operator->() const
		{	
		_Reference _Tmp = **this;
		return (&_Tmp); }

	_Myt& operator++()
		{	
		--current;
		return (*this); }

	_Myt operator++(int)
		{	
		_Myt _Tmp = *this;
		--current;
		return (_Tmp); }

	_Myt& operator--()
		{	
		++current;
		return (*this); }

	_Myt operator--(int)
		{	
		_Myt _Tmp = *this;
		++current;
		return (_Tmp); }

	bool operator==(const _Myt& _Right) const
		{	
		return (current == _Right.current); }

	bool operator!=(const _Myt& _Right) const
		{	
		return (!(*this == _Right)); }

protected:
	_BidIt current;
	};

		
template<class _Elem,
	class _Traits>
	class istreambuf_iterator
		: public iterator<input_iterator_tag,
			_Elem, typename _Traits::off_type, _Elem *, _Elem&>
	{	
public:
	typedef istreambuf_iterator<_Elem, _Traits> _Myt;
	typedef _Elem char_type;
	typedef _Traits traits_type;
	typedef basic_streambuf<_Elem, _Traits> streambuf_type;
	typedef basic_istream<_Elem, _Traits> istream_type;
	typedef typename traits_type::int_type int_type;

	istreambuf_iterator(streambuf_type *_Sb = 0) throw ()
		: _Strbuf(_Sb), _Got(_Sb == 0)
		{}	

	istreambuf_iterator(istream_type& _Istr) throw ()
		: _Strbuf(_Istr.rdbuf()), _Got(_Istr.rdbuf() == 0)
		{}	

	const _Elem& operator*() const
		{	
		if (!_Got)
			((_Myt *)this)->_Peek();
		return (_Val); }

	const _Elem *operator->() const
		{	
		return (&**this); }

	_Myt& operator++()
		{	
		_Inc();
		return (*this); }

	_Myt operator++(int)
		{	
		if (!_Got)
			_Peek();
		_Myt _Tmp = *this;
		_Inc();
		return (_Tmp); }

	bool equal(const _Myt& _Right) const
		{	
		if (!_Got)
			((_Myt *)this)->_Peek();
		if (!_Right._Got)
			((_Myt *)&_Right)->_Peek();
		return (_Strbuf == 0 && _Right._Strbuf == 0
			|| _Strbuf != 0 && _Right._Strbuf != 0); }

private:
	void _Inc()
		{	
		if (_Strbuf == 0
			|| traits_type::eq_int_type(traits_type::eof(),
				_Strbuf->sbumpc()))
			_Strbuf = 0, _Got = true;
		else
			_Got = false; }

	_Elem _Peek()
		{	
		int_type _Meta;
		if (_Strbuf == 0
			|| traits_type::eq_int_type(traits_type::eof(),
				_Meta = _Strbuf->sgetc()))
			_Strbuf = 0;
		else
			_Val = traits_type::to_char_type(_Meta);
		_Got = true;
		return (_Val); }

	streambuf_type *_Strbuf;	
	bool _Got;	
	_Elem _Val;	
	};

		
template<class _Elem,
	class _Traits> inline
	bool operator==(
		const istreambuf_iterator<_Elem, _Traits>& _Left,
		const istreambuf_iterator<_Elem, _Traits>& _Right)
	{	
	return (_Left.equal(_Right)); }

template<class _Elem,
	class _Traits> inline
	bool operator!=(
		const istreambuf_iterator<_Elem, _Traits>& _Left,
		const istreambuf_iterator<_Elem, _Traits>& _Right)
	{	
	return (!(_Left == _Right)); }

		
template<class _Elem,
	class _Traits>
	class ostreambuf_iterator
		: public _Outit
	{	
	typedef ostreambuf_iterator<_Elem, _Traits> _Myt;
public:
	typedef _Elem char_type;
	typedef _Traits traits_type;
	typedef basic_streambuf<_Elem, _Traits> streambuf_type;
	typedef basic_ostream<_Elem, _Traits> ostream_type;

	ostreambuf_iterator(streambuf_type *_Sb) throw ()
		: _Failed(false), _Strbuf(_Sb)
		{}	

	ostreambuf_iterator(ostream_type& _Ostr) throw ()
		: _Failed(false), _Strbuf(_Ostr.rdbuf())
		{}	

	_Myt& operator=(_Elem _Right)
		{	
		if (_Strbuf == 0
			|| traits_type::eq_int_type(_Traits::eof(),
				_Strbuf->sputc(_Right)))
			_Failed = true;
		return (*this); }

	_Myt& operator*()
		{	
		return (*this); }

	_Myt& operator++()
		{	
		return (*this); }

	_Myt& operator++(int)
		{	
		return (*this); }

	bool failed() const throw ()
		{	
		return (_Failed); }

private:
	bool _Failed;	
	streambuf_type *_Strbuf;	
	};



		
template<class _InIt,
	class _OutIt> inline
	_OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	
	return (_Copy_opt(_First, _Last, _Dest, _Ptr_cat(_First, _Dest))); }

template<class _InIt,
	class _OutIt> inline
	_OutIt _Copy_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
		_Nonscalar_ptr_iterator_tag)
	{	
	for (; _First != _Last; ++_Dest, ++_First)
		*_Dest = *_First;
	return (_Dest); }

template<class _InIt,
	class _OutIt> inline
	_OutIt _Copy_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
		_Scalar_ptr_iterator_tag)
	{	
	ptrdiff_t _Off = _Last - _First;	
	return ((_OutIt)memmove(&*_Dest, &*_First,
		_Off * sizeof (*_First)) + _Off); }

		
template<class _BidIt1,
	class _BidIt2> inline
	_BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
	{	
	return (_Copy_backward_opt(_First, _Last, _Dest,
		_Ptr_cat(_First, _Dest))); }

template<class _BidIt1,
	class _BidIt2> inline
	_BidIt2 _Copy_backward_opt(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest,
		_Nonscalar_ptr_iterator_tag)
	{	
	while (_First != _Last)
		*--_Dest = *--_Last;
	return (_Dest); }

template<class _InIt,
	class _OutIt> inline
	_OutIt _Copy_backward_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
		_Scalar_ptr_iterator_tag)
	{	
	ptrdiff_t _Off = _Last - _First;	
	return ((_OutIt)memmove(&*_Dest - _Off, &*_First,
		_Off * sizeof (*_First))); }

		
template<class _InIt1,
	class _InIt2> inline
	bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
	{	
	return (mismatch(_First1, _Last1, _First2).first == _Last1); }

inline bool equal(const char *_First1,
	const char *_Last1, const char *_First2)
	{	
	return (memcmp(_First1, _First2, _Last1 - _First1) == 0); }

inline bool equal(const signed char *_First1,
	const signed char *_Last1, const signed char *_First2)
	{	
	return (memcmp(_First1, _First2, _Last1 - _First1) == 0); }

inline bool equal(const unsigned char *_First1,
	const unsigned char *_Last1, const unsigned char *_First2)
	{	
	return (memcmp(_First1, _First2, _Last1 - _First1) == 0); }

		
template<class _InIt1,
	class _InIt2,
	class _Pr> inline
	bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
	{	
	return (mismatch(_First1, _Last1, _First2, _Pred).first == _Last1); }

		
template<class _FwdIt,
	class _Ty> inline
	void fill(_FwdIt _First, _FwdIt _Last, const _Ty& _Src)
	{	
	for (; _First != _Last; ++_First)
		*_First = _Src; }

inline void fill(char *_First, char *_Last, int _Src)
	{	
	memset(_First, _Src, _Last - _First); }

inline void fill(signed char *_First, signed char *_Last, int _Src)
	{	
	memset(_First, _Src, _Last - _First); }

inline void fill(unsigned char *_First, unsigned char *_Last, int _Src)
	{	
	memset(_First, _Src, _Last - _First); }

		
template<class _OutIt,
	class _Diff,
	class _Ty> inline
	void fill_n(_OutIt _First, _Diff _Num, const _Ty& _Src)
	{	
	for (; 0 < _Num; --_Num, ++_First)
		*_First = _Src; }

inline void fill_n(char *_First, size_t _Num, int _Src)
	{	
	memset(_First, _Src, _Num); }

inline void fill_n(signed char *_First, size_t _Num, int _Src)
	{	
	memset(_First, _Src, _Num); }

inline void fill_n(unsigned char *_First, size_t _Num, int _Src)
	{	
	memset(_First, _Src, _Num); }

		
template<class _InIt1,
	class _InIt2> inline
	bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _InIt2 _Last2)
	{	
	for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
		if (*_First1 < *_First2)
			return (true);
		else if (*_First2 < *_First1)
			return (false);
	return (_First1 == _Last1 && _First2 != _Last2); }

inline bool lexicographical_compare(
	const unsigned char *_First1, const unsigned char *_Last1,
	const unsigned char *_First2, const unsigned char *_Last2)
	{	
	ptrdiff_t _Num1 = _Last1 - _First1;
	ptrdiff_t _Num2 = _Last2 - _First2;
	int _Ans = memcmp(_First1, _First2, _Num1 < _Num2 ? _Num1 : _Num2);
	return (_Ans < 0 || _Ans == 0 && _Num1 < _Num2); }

#line 996 "/usr/include/CC/xutility"

		
template<class _InIt1,
	class _InIt2,
	class _Pr> inline
	bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
	{	
	for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
		if (_Pred(*_First1, *_First2))
			return (true);
		else if (_Pred(*_First2, *_First1))
			return (false);
	return (_First1 == _Last1 && _First2 != _Last2); }






		
template<class _Ty> inline
	const _Ty& (max)(const _Ty& _Left, const _Ty& _Right)
	{	
	return (_Left < _Right ? _Right : _Left); }

		
template<class _Ty,
	class _Pr> inline
	const _Ty& (max)(const _Ty& _Left, const _Ty& _Right, _Pr _Pred)
	{	
	return (_Pred(_Left, _Right) ? _Right : _Left); }

		
template<class _Ty> inline
	const _Ty& (min)(const _Ty& _Left, const _Ty& _Right)
	{	
	return (_Right < _Left ? _Right : _Left); }

		
template<class _Ty,
	class _Pr> inline
	const _Ty& (min)(const _Ty& _Left, const _Ty& _Right, _Pr _Pred)
	{	
	return (_Pred(_Right, _Left) ? _Right : _Left); }

		
template<class _InIt1,
	class _InIt2> inline
	pair<_InIt1, _InIt2>
		mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
	{	
	for (; _First1 != _Last1 && *_First1 == *_First2; )
		++_First1, ++_First2;
	return (pair<_InIt1, _InIt2>(_First1, _First2)); }

		
template<class _InIt1,
	class _InIt2,
	class _Pr> inline
	pair<_InIt1, _InIt2>
		mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
	{	
	for (; _First1 != _Last1 && _Pred(*_First1, *_First2); )
		++_First1, ++_First2;
	return (pair<_InIt1, _InIt2>(_First1, _First2)); }

}	





 
















 
#line 5 "/usr/include/CC/iterator"

namespace std {

		
template<class _Container>
	class back_insert_iterator
		: public _Outit
	{	
public:
	typedef _Container container_type;
	typedef typename _Container::reference reference;

	explicit back_insert_iterator(_Container& _Cont)
		: container(&_Cont)
		{}	

	back_insert_iterator<_Container>& operator=(
		typename _Container::const_reference _Val)
		{	
		container->push_back(_Val);
		return (*this); }

	back_insert_iterator<_Container>& operator*()
		{	
		return (*this); }

	back_insert_iterator<_Container>& operator++()
		{	
		return (*this); }

	back_insert_iterator<_Container> operator++(int)
		{	
		return (*this); }

protected:
	_Container *container;	
	};

		
template<class _Container> inline
	back_insert_iterator<_Container> back_inserter(_Container& _Cont)
	{	
	return (back_insert_iterator<_Container>(_Cont)); }

		
template<class _Container>
	class front_insert_iterator
		: public _Outit
	{	
public:
	typedef _Container container_type;
	typedef typename _Container::reference reference;

	explicit front_insert_iterator(_Container& _Cont)
		: container(&_Cont)
		{}	

	front_insert_iterator<_Container>& operator=(
		typename _Container::const_reference _Val)
		{	
		container->push_front(_Val);
		return (*this); }

	front_insert_iterator<_Container>& operator*()
		{	
		return (*this); }

	front_insert_iterator<_Container>& operator++()
		{	
		return (*this); }

	front_insert_iterator<_Container> operator++(int)
		{	
		return (*this); }

protected:
	_Container *container;	
	};

		
template<class _Container> inline
	front_insert_iterator<_Container> front_inserter(_Container& _Cont)
	{	
	return (front_insert_iterator<_Container>(_Cont)); }

		
template<class _Container>
	class insert_iterator
		: public _Outit
	{	
public:
	typedef _Container container_type;
	typedef typename _Container::reference reference;

	insert_iterator(_Container& _Cont, typename _Container::iterator _Where)
		: container(&_Cont), iter(_Where)
		{}	

	insert_iterator<_Container>& operator=(
		typename _Container::const_reference _Val)
		{	
		iter = container->insert(iter, _Val);
		++iter;
		return (*this); }

	insert_iterator<_Container>& operator*()
		{	
		return (*this); }

	insert_iterator<_Container>& operator++()
		{	
		return (*this); }

	insert_iterator<_Container>& operator++(int)
		{	
		return (*this); }

protected:
	_Container *container;	
	typename _Container::iterator iter;	
	};

		
template<class _Container,
	class _Iter> inline
	insert_iterator<_Container> inserter(_Container& _Cont, _Iter _Where)
	{	
	return (insert_iterator<_Container>(_Cont,
		_Container::iterator(_Where))); }

		
template<class _Ty,
	class _Elem = char,
	class _Traits = char_traits<_Elem>,
	class _Dist = ptrdiff_t>
	class istream_iterator
		: public iterator<input_iterator_tag, _Ty, _Dist, _Ty *, _Ty&>
	{	
public:
	typedef istream_iterator<_Ty, _Elem, _Traits, _Dist> _Myt;
	typedef _Elem char_type;
	typedef _Traits traits_type;
	typedef basic_istream<_Elem, _Traits> istream_type;

	istream_iterator()
		: _Myistr(0)
		{}	

	istream_iterator(istream_type& _Istr)
		: _Myistr(&_Istr)
		{	
		_Getval(); }

	const _Ty& operator*() const
		{	
		return (_Myval); }

	const _Ty *operator->() const
		{	
		return (&**this); }

	_Myt& operator++()
		{	
		_Getval();
		return (*this); }

	_Myt operator++(int)
		{	
		_Myt _Tmp = *this;
		_Getval();
		return (_Tmp); }

	bool _Equal(const _Myt& _Right) const
		{	
		return (_Myistr == _Right._Myistr); }

protected:
	void _Getval()
		{	
		if (_Myistr != 0 && !(*_Myistr >> _Myval))
			_Myistr = 0; }

	istream_type *_Myistr;	
	_Ty _Myval;	
	};

		
template<class _Ty, class _Elem, class _Traits, class _Dist> inline
	bool operator==(
		const istream_iterator<_Ty, _Elem, _Traits, _Dist>& _Left,
		const istream_iterator<_Ty, _Elem, _Traits, _Dist>& _Right)
	{	
	return (_Left._Equal(_Right)); }

template<class _Ty, class _Elem, class _Traits, class _Dist> inline
	bool operator!=(
		const istream_iterator<_Ty, _Elem, _Traits, _Dist>& _Left,
		const istream_iterator<_Ty, _Elem, _Traits, _Dist>& _Right)
	{	
	return (!(_Left == _Right)); }

		
template<class _Ty, class _Elem = char,
	class _Traits = char_traits<_Elem> >
	class ostream_iterator
		: public _Outit
	{	
public:
	typedef _Elem char_type;
	typedef _Traits traits_type;
	typedef basic_ostream<_Elem, _Traits> ostream_type;

	ostream_iterator(ostream_type& _Ostr,
		const _Elem *_Delim = 0)
		: _Myostr(&_Ostr), _Mydelim(_Delim)
		{}	

	ostream_iterator<_Ty, _Elem, _Traits>& operator=(const _Ty& _Val)
		{	
		*_Myostr << _Val;
		if (_Mydelim != 0)
			*_Myostr << _Mydelim;
		return (*this); }

	ostream_iterator<_Ty, _Elem, _Traits>& operator*()
		{	
		return (*this); }

	ostream_iterator<_Ty, _Elem, _Traits>& operator++()
		{	
		return (*this); }

	ostream_iterator<_Ty, _Elem, _Traits> operator++(int)
		{	
		return (*this); }

protected:
	const _Elem *_Mydelim;	
	ostream_type *_Myostr;	
	};

		
template<class _Iter> inline
	typename iterator_traits<_Iter>::value_type *_Val_type(_Iter)
	{	
	return (0); }

		
template<class _InIt, class _Diff> inline
	void advance(_InIt& _Where, _Diff _Off)
	{	
	_Advance(_Where, _Off, _Iter_cat(_Where)); }

template<class _InIt, class _Diff> inline
	void _Advance(_InIt& _Where, _Diff _Off, input_iterator_tag)
	{	
	for (; 0 < _Off; --_Off)
		++_Where; }

template<class _FI, class _Diff> inline
	void _Advance(_FI& _Where, _Diff _Off, forward_iterator_tag)
	{	
	for (; 0 < _Off; --_Off)
		++_Where; }

template<class _BI, class _Diff> inline
	void _Advance(_BI& _Where, _Diff _Off, bidirectional_iterator_tag)
	{	
	for (; 0 < _Off; --_Off)
		++_Where;
	for (; _Off < 0; ++_Off)
		--_Where; }

template<class _RI, class _Diff> inline
	void _Advance(_RI& _Where, _Diff _Off, random_access_iterator_tag)
	{	
	_Where += _Off; }

		
template<class _Iter> inline
	typename iterator_traits<_Iter>::difference_type
		*_Dist_type(_Iter)
	{	
	return (0); }

}	





 
















 
#line 31 "../../include/QtCore/../../src/corelib/tools/qlist.h"
#line 1 "/usr/include/CC/list"

#line 1 "/usr/include/CC/functional"





namespace std {

		
template<class _Arg,
	class _Result>
	struct unary_function
	{	
	typedef _Arg argument_type;
	typedef _Result result_type;
	};

		
template<class _Arg1,
	class _Arg2,
	class _Result>
	struct binary_function
	{	
	typedef _Arg1 first_argument_type;
	typedef _Arg2 second_argument_type;
	typedef _Result result_type;
	};

		
template<class _Ty>
	struct plus
		: public binary_function<_Ty, _Ty, _Ty>
	{	
	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left + _Right); }
	};

		
template<class _Ty>
	struct minus
		: public binary_function<_Ty, _Ty, _Ty>
	{	
	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left - _Right); }
	};

		
template<class _Ty>
	struct multiplies
		: public binary_function<_Ty, _Ty, _Ty>
	{	
	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left * _Right); }
	};

		
template<class _Ty>
	struct divides
		: public binary_function<_Ty, _Ty, _Ty>
	{	
	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left / _Right); }
	};

		
template<class _Ty>
	struct modulus
		: public binary_function<_Ty, _Ty, _Ty>
	{	
	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left % _Right); }
	};

		
template<class _Ty>
	struct negate
		: public unary_function<_Ty, _Ty>
	{	
	_Ty operator()(const _Ty& _Left) const
		{	
		return (-_Left); }
	};

		
template<class _Ty>
	struct equal_to
		: public binary_function<_Ty, _Ty, bool>
	{	
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left == _Right); }
	};

		
template<class _Ty>
	struct not_equal_to
		: public binary_function<_Ty, _Ty, bool>
	{	
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left != _Right); }
	};

		
template<class _Ty>
	struct greater
		: public binary_function<_Ty, _Ty, bool>
	{	
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left > _Right); }
	};

		
template<class _Ty>
	struct less
		: public binary_function<_Ty, _Ty, bool>
	{	
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left < _Right); }
	};

		
template<class _Ty>
	struct greater_equal
		: public binary_function<_Ty, _Ty, bool>
	{	
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left >= _Right); }
	};

		
template<class _Ty>
	struct less_equal
		: public binary_function<_Ty, _Ty, bool>
	{	
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left <= _Right); }
	};

		
template<class _Ty>
	struct logical_and
		: public binary_function<_Ty, _Ty, bool>
	{	
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left && _Right); }
	};

		
template<class _Ty>
	struct logical_or
		: public binary_function<_Ty, _Ty, bool>
	{	
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
		{	
		return (_Left || _Right); }
	};

		
template<class _Ty>
	struct logical_not
		: public unary_function<_Ty, bool>
	{	
	bool operator()(const _Ty& _Left) const
		{	
		return (!_Left); }
	};

		
template<class _Ufn>
	class unary_negate
	: public unary_function<typename _Ufn::argument_type, bool>
	{	
public:
	explicit unary_negate(const _Ufn& _Fn)
		: _Functor(_Fn)
		{}	

	bool operator()(const typename _Ufn::argument_type& _Left) const
		{	
		return (!_Functor(_Left)); }

protected:
	_Ufn _Functor;	
	};

		
template<class _Ufn> inline
	unary_negate<_Ufn> not1(const _Ufn& _Left)
	{	
	return (unary_negate<_Ufn>(_Left)); }

		
template<class _Bfn>
	class binary_negate
		: public binary_function<typename _Bfn::first_argument_type,
			typename _Bfn::second_argument_type, bool>
	{	
public:
	explicit binary_negate(const _Bfn& _Fn)
		: _Functor(_Fn)
		{}	

	bool operator()(const typename _Bfn::first_argument_type& _Left,
		const typename _Bfn::second_argument_type& _Right) const
		{	
		return (!_Functor(_Left, _Right)); }

protected:
	_Bfn _Functor;	
	};

		
template<class _Bfn> inline
	binary_negate<_Bfn> not2(const _Bfn& _Left)
	{	
	return (binary_negate<_Bfn>(_Left)); }

		
template<class _Bfn>
	class binder1st
		: public unary_function<typename _Bfn::second_argument_type,
			typename _Bfn::result_type>
	{	
public:
	typedef unary_function<typename _Bfn::second_argument_type,
		typename _Bfn::result_type> _Base;
	typedef typename _Base::argument_type argument_type;
	typedef typename _Base::result_type result_type;

	binder1st(const _Bfn& _Fn,
		const typename _Bfn::first_argument_type& _Left)
		: op(_Fn), value(_Left)
		{}	

	result_type operator()(const argument_type& _Left) const
		{	
		return (op(value, _Left)); }

protected:
	_Bfn op;	
	typename _Bfn::first_argument_type value;	
	};

		
template<class _Bfn,
	class _Ty> inline
	binder1st<_Bfn> bind1st(const _Bfn& _Left, const _Ty& _Right)
		{	
		typename _Bfn::first_argument_type _Val(_Right);
		return (binder1st<_Bfn>(_Left, _Val)); }

		
template<class _Bfn>
	class binder2nd
		: public unary_function<typename _Bfn::first_argument_type,
			typename _Bfn::result_type>
	{	
public:
	typedef unary_function<typename _Bfn::first_argument_type,
		typename _Bfn::result_type> _Base;
	typedef typename _Base::argument_type argument_type;
	typedef typename _Base::result_type result_type;

	binder2nd(const _Bfn& _Fn,
		const typename _Bfn::second_argument_type& _Right)
		: op(_Fn), value(_Right)
		{}	

	result_type operator()(const argument_type& _Left) const
		{	
		return (op(_Left, value)); }

protected:
	_Bfn op;	
	typename _Bfn::second_argument_type value;	
	};

		
template<class _Bfn,
	class _Ty> inline
	binder2nd<_Bfn> bind2nd(const _Bfn& _Left, const _Ty& _Right)
	{	
	typename _Bfn::second_argument_type _Val(_Right);
	return (binder2nd<_Bfn>(_Left, _Val)); }

		
template<class _Arg,
	class _Result>
	class pointer_to_unary_function
		: public unary_function<_Arg, _Result>
	{	
public:
	explicit pointer_to_unary_function(_Result (*_Left)(_Arg))
		: _Pfun(_Left)
		{}	

	_Result operator()(_Arg _Left) const
		{	
		return (_Pfun(_Left)); }

protected:
	_Result (*_Pfun)(_Arg);	
	};

		
template<class _Arg1,
	class _Arg2,
	class _Result>
	class pointer_to_binary_function
		: public binary_function<_Arg1, _Arg2, _Result>
	{	
public:
	explicit pointer_to_binary_function(
		_Result (*_Left)(_Arg1, _Arg2))
		: _Pfun(_Left)
		{}	

	_Result operator()(_Arg1 _Left, _Arg2 _Right) const
		{	
		return (_Pfun(_Left, _Right)); }

protected:
	_Result (*_Pfun)(_Arg1, _Arg2);	
	};

		
template<class _Arg,
	class _Result> inline
	pointer_to_unary_function<_Arg, _Result>
		ptr_fun(_Result (*_Left)(_Arg))
	{	
	return (pointer_to_unary_function<_Arg, _Result>(_Left)); }

template<class _Arg1,
	class _Arg2,
	class _Result> inline
	pointer_to_binary_function<_Arg1, _Arg2, _Result>
		ptr_fun(_Result (*_Left)(_Arg1, _Arg2))
	{	
	return (pointer_to_binary_function<_Arg1, _Arg2, _Result>(_Left)); }

		
template<class _Result,
	class _Ty>
	class mem_fun_t
		: public unary_function<_Ty *, _Result>
	{	
public:
	explicit mem_fun_t(_Result (_Ty::*_Pm)())
		: _Pmemfun(_Pm)
		{}	

	_Result operator()(_Ty *_Pobject) const
		{	
		return ((_Pobject->*_Pmemfun)()); }

private:
	_Result (_Ty::*_Pmemfun)();	
	};

		
template<class _Result,
	class _Ty,
	class _Arg>
	class mem_fun1_t
		: public binary_function<_Ty *, _Arg, _Result>
	{	
public:
	explicit mem_fun1_t(_Result (_Ty::*_Pm)(_Arg))
		: _Pmemfun(_Pm)
		{}	

	_Result operator()(_Ty *_Pobject, _Arg _Val) const
		{	
		return ((_Pobject->*_Pmemfun)(_Val)); }

private:
	_Result (_Ty::*_Pmemfun)(_Arg);	
	};

		
template<class _Result,
	class _Ty>
	class const_mem_fun_t
		: public unary_function<const _Ty *, _Result>
	{	
public:
	explicit const_mem_fun_t(_Result (_Ty::*_Pm)() const)
		: _Pmemfun(_Pm)
		{}	

	_Result operator()(const _Ty *_Pobject) const
		{	
		return ((_Pobject->*_Pmemfun)()); }

private:
	_Result (_Ty::*_Pmemfun)() const;	
	};

		
template<class _Result,
	class _Ty,
	class _Arg>
	class const_mem_fun1_t
		: public binary_function<_Ty *, _Arg, _Result>
	{	
public:
	explicit const_mem_fun1_t(_Result (_Ty::*_Pm)(_Arg) const)
		: _Pmemfun(_Pm)
		{}	

	_Result operator()(const _Ty *_Pobject, _Arg _Val) const
		{	
		return ((_Pobject->*_Pmemfun)(_Val)); }

private:
	_Result (_Ty::*_Pmemfun)(_Arg) const;	
	};

		
template<class _Result,
	class _Ty> inline
	mem_fun_t<_Result, _Ty> mem_fun(_Result (_Ty::*_Pm)())
	{	
	return (mem_fun_t<_Result, _Ty>(_Pm)); }

template<class _Result,
	class _Ty,
	class _Arg> inline
	mem_fun1_t<_Result, _Ty, _Arg> mem_fun(_Result (_Ty::*_Pm)(_Arg))
	{	
	return (mem_fun1_t<_Result, _Ty, _Arg>(_Pm)); }

template<class _Result,
	class _Ty> inline
	const_mem_fun_t<_Result, _Ty>
		mem_fun(_Result (_Ty::*_Pm)() const)
	{	
	return (const_mem_fun_t<_Result, _Ty>(_Pm)); }

template<class _Result,
	class _Ty,
	class _Arg> inline
	const_mem_fun1_t<_Result, _Ty, _Arg>
		mem_fun(_Result (_Ty::*_Pm)(_Arg) const)
	{	
	return (const_mem_fun1_t<_Result, _Ty, _Arg>(_Pm)); }

		
template<class _Result,
	class _Ty>
	class mem_fun_ref_t
		: public unary_function<_Ty, _Result>
	{	
public:
	explicit mem_fun_ref_t(_Result (_Ty::*_Pm)())
		: _Pmemfun(_Pm)
		{}	

	_Result operator()(_Ty& _Left) const
		{	
		return ((_Left.*_Pmemfun)()); }

private:
	_Result (_Ty::*_Pmemfun)();	
	};

		
template<class _Result,
	class _Ty,
	class _Arg>
	class mem_fun1_ref_t
		: public binary_function<_Ty, _Arg, _Result>
	{	
public:
	explicit mem_fun1_ref_t(_Result (_Ty::*_Pm)(_Arg))
		: _Pmemfun(_Pm)
		{}	

	_Result operator()(_Ty& _Left, _Arg _Val) const
		{	
		return ((_Left.*_Pmemfun)(_Val)); }

private:
	_Result (_Ty::*_Pmemfun)(_Arg);	
	};

		
template<class _Result,
	class _Ty>
	class const_mem_fun_ref_t
		: public unary_function<_Ty, _Result>
	{	
public:
	explicit const_mem_fun_ref_t(_Result (_Ty::*_Pm)() const)
		: _Pmemfun(_Pm)
		{}	

	_Result operator()(const _Ty& _Left) const
		{	
		return ((_Left.*_Pmemfun)()); }

private:
	_Result (_Ty::*_Pmemfun)() const;	
	};

		
template<class _Result,
	class _Ty,
	class _Arg>
	class const_mem_fun1_ref_t
		: public binary_function<_Ty, _Arg, _Result>
	{	
public:
	explicit const_mem_fun1_ref_t(_Result (_Ty::*_Pm)(_Arg) const)
		: _Pmemfun(_Pm)
		{}	

	_Result operator()(const _Ty& _Left, _Arg _Val) const
		{	
		return ((_Left.*_Pmemfun)(_Val)); }

private:
	_Result (_Ty::*_Pmemfun)(_Arg) const;	
	};

		
template<class _Result,
	class _Ty> inline
	mem_fun_ref_t<_Result, _Ty> mem_fun_ref(_Result (_Ty::*_Pm)())
	{	
	return (mem_fun_ref_t<_Result, _Ty>(_Pm)); }

template<class _Result,
	class _Ty,
	class _Arg> inline
	mem_fun1_ref_t<_Result, _Ty, _Arg>
		mem_fun_ref(_Result (_Ty::*_Pm)(_Arg))
	{	
	return (mem_fun1_ref_t<_Result, _Ty, _Arg>(_Pm)); }

template<class _Result,
	class _Ty> inline
	const_mem_fun_ref_t<_Result, _Ty>
		mem_fun_ref(_Result (_Ty::*_Pm)() const)
	{	
	return (const_mem_fun_ref_t<_Result, _Ty>(_Pm)); }

template<class _Result,
	class _Ty,
	class _Arg> inline
	const_mem_fun1_ref_t<_Result, _Ty, _Arg>
		mem_fun_ref(_Result (_Ty::*_Pm)(_Arg) const)
	{	
	return (const_mem_fun1_ref_t<_Result, _Ty, _Arg>(_Pm)); }

}	





 
















 
#line 5 "/usr/include/CC/list"
#line 1 "/usr/include/CC/memory"

#line 1 "/usr/include/CC/xmemory"

#line 1 "/usr/include/CC/cstdlib"

#line 1 "/usr/include/stdlib.h"










  



#ident	"@(#)unixsrc:usr/src/i386/head/stdlib.h /main/1"

typedef	struct
{
	int	quot;
	int	rem;
} div_t;

typedef struct
{
	long	quot;
	long	rem;
} ldiv_t;











#line 45 "/usr/include/stdlib.h"












#line 67 "/usr/include/stdlib.h"




extern "C" {


extern unsigned char	__ctype[];



extern double	atof(const char *);
extern int	atoi(const char *);
extern long	atol(const char *);
extern double	strtod(const char *, char **);
	 
extern float	strtof(const char *, char **);
extern long	strtol(const char *, char **, int);
long double	strtold(const char *, char **);
long long	strtoll(const char *, char **, int);
unsigned long	strtoul(const char *, char **, int);
unsigned long long strtoull(const char *, char **, int);

extern int	rand(void);
extern void	srand(unsigned int);

extern void	*calloc(size_t, size_t);
extern void	free(void *);
extern void	*malloc(size_t);
extern void	*realloc(void *, size_t);

extern void	_Exit(int);





extern char	*getenv(const char *);
extern int	system(const char *);

#line 113 "/usr/include/stdlib.h"

extern int	abs(int);
extern div_t	div(int, int);
extern long	labs(long);
extern ldiv_t	ldiv(long, long);

extern int	mbtowc(wchar_t *, const char *, size_t);
extern int	mblen(const char *, size_t);
extern int	wctomb(char *, wchar_t);

extern size_t	mbstowcs(wchar_t *, const char *, size_t);
extern size_t	wcstombs(char *, const wchar_t *, size_t);




extern double	drand48(void);
extern double	erand48(unsigned short *);
extern long	jrand48(unsigned short *);
extern void	lcong48(unsigned short *);
extern long	lrand48(void);
extern long	mrand48(void);
extern long	nrand48(unsigned short *);
extern int	putenv(char *);
unsigned short	*seed48(unsigned short *);
extern void	setkey(const char *);
extern void	srand48(long);








extern long	a64l(const char *);
extern char	*ecvt(double, int, int *, int *);
extern char	*fcvt(double, int, int *, int *);
extern char	*gcvt(double, int, char *);
extern int	getsubopt(char **, char *const *, char **);
extern int	grantpt(int);
extern char	*initstate(unsigned, char * , int);
extern char	*l64a(long);
extern int	mkstemp(char *);
extern char	*mktemp(char *);
extern char	*ptsname(int);
extern long	random(void);
extern char	*realpath(const char *, char *);
extern char	*setstate(char *);
extern void	srandom(unsigned);
extern int	ttyslot(void);
extern int	unlockpt(int);
extern void	*valloc(size_t);







extern int	rand_r(unsigned int *);






typedef struct  
{
	long long	quot;
	long long	rem;
} lldiv_t;



struct mallinfo {
	size_t	arena;		 
	size_t	ordblks;	 
	size_t	smblks;		 
	size_t	hblks;		 
	size_t	hblkhd;		 
	size_t	usmblks;	 
	size_t	fsmblks;	 
	size_t	uordblks;	 
	size_t	fordblks;	 
	size_t	keepcost;	 
};


long long	atoll(const char *);  
extern int	dup2(int, int);
extern char	*ecvtl(long double, int, int *, int *);
extern char	*fcvtl(long double, int, int *, int *);
extern char	*gcvtl(long double, int, char *);
extern char	*getcwd(char *, size_t);
extern char	*getlogin(void);
extern int	getopt(int, char *const *, const char *);
extern char	*optarg;
extern int	optind, opterr, optopt;
extern char	*getpass(const char *);
extern int	getpw(int, char *);
extern int	isatty(int);
extern void	l3tol(long *, const char *, int);
extern char	*l64a_r(long, char *, size_t);
long long	llabs(long long);  
extern lldiv_t	lldiv(long long, long long);  
extern void	ltol3(char *, const long *, int);
struct mallinfo	mallinfo(void);
extern void	*memalign(size_t, size_t);
extern void	swab(const void *, void *, ssize_t);
extern char	*ttyname(int);
extern double	wcstod(const wchar_t *, wchar_t **);
	 
extern float	wcstof(const wchar_t *, wchar_t **);
extern long	wcstol(const wchar_t *, wchar_t **, int);
long double	wcstold(const wchar_t *, wchar_t **);
long long	wcstoll(const wchar_t *, wchar_t **, int);
unsigned long	wcstoul(const wchar_t *, wchar_t **, int);
unsigned long long wcstoull(const wchar_t *, wchar_t **, int);
extern int	_xgetlogin_r(char *, size_t);
extern int	_xttyname_r(int, char *, size_t);

#line 248 "/usr/include/stdlib.h"



static int
getlogin_r(char *__1, size_t __2)
{
	return _xgetlogin_r(__1, __2);
}




static int
ttyname_r(int __1, char *__2, size_t __3)
{
	return _xttyname_r(__1, __2, __3);
}








}  

extern "C++" {
inline long abs(long __1){ return labs(__1); }
inline ldiv_t div(long __1, long __2){ return ldiv(__1, __2); }



inline long long abs(long long __1){ return llabs(__1); }
inline lldiv_t div(long long __1, long long __2){ return lldiv(__1, __2); }

}

#line 1 "/usr/include/CC/cstdlib"

#line 65 "/usr/include/CC/cstdlib"




 
#line 288 "/usr/include/stdlib.h"




#line 5 "/usr/include/CC/cstdlib"

namespace std {
using ::size_t; using ::div_t; using ::ldiv_t;
using ::abs; using ::atof; using ::atoi; using ::atol;
using ::calloc; using ::div;
using ::free; using ::getenv;
using ::labs; using ::ldiv; using ::malloc;
using ::mblen; using ::mbstowcs; using ::mbtowc;
using ::rand; using ::realloc;
using ::srand; using ::strtod; using ::strtol;
using ::strtoul; using ::system;
using ::wcstombs; using ::wctomb;


extern "C" typedef void (*_P_C_AF)(void);

extern "C++" typedef void (*_P_CPLUSPLUS_AF)(void);

extern "C" typedef int (*_P_C_CF)(const void *, const void *);

extern "C++" void exit(int);









extern "C++" int atexit(void (*_f)(void));	
extern "C++" inline int atexit(_P_C_AF _f) {		
	return std::atexit(reinterpret_cast<_P_CPLUSPLUS_AF>(_f));
}

extern "C++" void abort(void);

extern "C" void* bsearch(const void* _key, const void* _base, 
			size_t _nmemb, size_t _size,
			int (*_compar)(const void*, const void*));
extern "C++" inline void* bsearch(const void* _key, const void* _base, 
			size_t _nmemb, size_t _size,
			int (*_compar)(const void*, const void*)) {
	return std::bsearch(_key, _base, _nmemb, _size, 
				reinterpret_cast<_P_C_CF>(_compar));
}

extern "C" void qsort(void* _base, size_t _nel, size_t _width,
           int (*_compar)(const void*, const void*));
extern "C++" inline void qsort(void* _base, size_t _nel, size_t _width,
           int (*_compar)(const void*, const void*)) {
	std::qsort(_base, _nel, _width, reinterpret_cast<_P_C_CF>(_compar));
}

}	

using std::exit; using std::atexit; using std::abort;
using std::bsearch; using std::qsort;






 
#line 5 "/usr/include/CC/xmemory"
#line 1 "/usr/include/CC/new"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/new /main/1"

 


 




#line 1 "/usr/include/CC/exception"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/exception /main/1"






namespace std {

  class exception {
  public:
    exception() throw();
    exception(const exception&) throw();
    exception& operator=(const exception&) throw();
    virtual ~exception() throw();
    virtual const char* what() const throw();
  protected:
    exception(const char*); 
  private:
    char* _Desc;
  };

  class bad_exception : public exception {
  public:
    bad_exception() throw();
    bad_exception(const bad_exception&) throw();
    bad_exception& operator=(const bad_exception&) throw();
    virtual ~bad_exception() throw();
    virtual const char* what() const throw();
  };

  typedef void (*unexpected_handler)();
  unexpected_handler set_unexpected(unexpected_handler) throw();
  void unexpected();

  typedef void (*terminate_handler)();
  terminate_handler set_terminate(terminate_handler) throw();
  void terminate();

  bool uncaught_exception();

}

#line 13 "/usr/include/CC/new"

namespace std {

  class bad_alloc : public exception {
  public:
    bad_alloc() throw();
    bad_alloc(const bad_alloc&) throw();
    bad_alloc& operator=(const bad_alloc&) throw();
    virtual ~bad_alloc() throw();
    virtual const char* what() const throw();
  };

  typedef void (*new_handler)();
  new_handler set_new_handler(new_handler);
  struct nothrow_t {};
  extern const nothrow_t nothrow;

}   



 
void *operator new(size_t) throw(std::bad_alloc);



 
void *operator new(size_t, const std::nothrow_t&) throw();



 
void operator delete(void*) throw();





 



 
void *operator new[](size_t) throw(std::bad_alloc);



 
void *operator new[](size_t,
                     const std::nothrow_t&) throw();



 
void operator delete[](void*) throw();





 



 
void *operator new(size_t, void*) throw();



 
void *operator new[](size_t, void*) throw();




 




 

#line 6 "/usr/include/CC/xmemory"








#line 22 "/usr/include/CC/xmemory"


namespace std {
		
template<class _Ty> inline
	_Ty  *_Allocate(size_t _Count, _Ty  *)
	{	
	return ((_Ty  *)operator new(_Count * sizeof (_Ty))); }

		
template<class _T1,
	class _T2> inline
	void _Construct(_T1  *_Ptr, const _T2& _Val)
	{	
	new ((void  *)_Ptr) _T1(_Val); }

		
template<class _Ty> inline
	void _Destroy(_Ty  *_Ptr)
	{	
	(_Ptr)->~_Ty(); }

template<> inline
	void _Destroy(char  *)
	{}	

template<> inline
	void _Destroy(wchar_t  *)
	{}	

		
template<class _Ty>
	class allocator
	{	
public:
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	typedef _Ty  *pointer;
	typedef const _Ty  *const_pointer;
	typedef _Ty & reference;
	typedef const _Ty & const_reference;
	typedef _Ty value_type;

	template<class _Other>
		struct rebind
		{	
		typedef allocator<_Other> other;
		};

	pointer address(reference _Val) const
		{	
		return (&_Val); }

	const_pointer address(const_reference _Val) const
		{	
		return (&_Val); }

	allocator()
		{}	

	allocator(const allocator<_Ty>&)
		{}	

	template<class _Other>
		allocator(const allocator<_Other>&)
		{}	

	template<class _Other>
		allocator<_Ty>& operator=(const allocator<_Other>&)
		{	
		return (*this); }

	template<class _Other>
		pointer allocate(size_type _Count, const _Other *)
		{	
		return (_Allocate(_Count, (pointer)0)); }

	pointer allocate(size_type _Count)
		{	
		return (_Allocate(_Count, (pointer)0)); }

	void deallocate(pointer _Ptr, size_type)
		{	
		operator delete(_Ptr); }

	void construct(pointer _Ptr, const _Ty& _Val)
		{	
		_Construct(_Ptr, _Val); }

	void destroy(pointer _Ptr)
		{	
		_Destroy(_Ptr); }

	size_t max_size() const
		{	
		size_t _Count = (size_t)(-1) / sizeof (_Ty);
		return (0 < _Count ? _Count : 1); }
	};

		
template<class _Ty,
	class _Other> inline
	bool operator==(const allocator<_Ty>&, const allocator<_Other>&)
	{	
	return (true); }

template<class _Ty,
	class _Other> inline
	bool operator!=(const allocator<_Ty>&, const allocator<_Other>&)
	{	
	return (false); }

		
template<> class allocator<void>
	{	
public:
	typedef void _Ty;
	typedef _Ty  *pointer;
	typedef const _Ty  *const_pointer;
	typedef _Ty value_type;

	template<class _Other>
		struct rebind
		{	
		typedef allocator<_Other> other;
		};

	allocator()
		{}	

	allocator(const allocator<_Ty>&)
		{}	

	template<class _Other>
		allocator(const allocator<_Other>&)
		{}	

	template<class _Other>
		allocator<_Ty>& operator=(const allocator<_Other>&)
		{	
		return (*this); }
	};

		
template<class _Ty,
	class _Alloc> inline
	void _Destroy_range(_Ty *_First, _Ty *_Last, _Alloc& _Al)
	{	
	_Destroy_range(_First, _Last, _Al, _Ptr_cat(_First, _Last)); }

template<class _Ty,
	class _Alloc> inline
	void _Destroy_range(_Ty *_First, _Ty *_Last, _Alloc& _Al,
		_Nonscalar_ptr_iterator_tag)
	{	
	for (; _First != _Last; ++_First)
		_Al.destroy(_First); }

template<class _Ty> inline
	void _Destroy_range(_Ty *_First, _Ty *_Last, allocator<_Ty>& _Al,
		_Scalar_ptr_iterator_tag)
	{}	

}	





 
















 
#line 6 "/usr/include/CC/memory"

namespace std {

		
template<class _Ty> inline
	pair<_Ty  *, ptrdiff_t>
		get_temporary_buffer(ptrdiff_t _Count)
	{	
	_Ty  *_Pbuf;

	for (_Pbuf = 0; 0 < _Count; _Count /= 2)
		if ((_Pbuf = (_Ty  *)operator new(
			(size_t)_Count * sizeof (_Ty), nothrow)) != 0)
			break;

	return (pair<_Ty  *, ptrdiff_t>(_Pbuf, _Count)); }

		
template<class _Ty> inline
	void return_temporary_buffer(_Ty *_Pbuf)
	{	
	operator delete(_Pbuf); }

		
template<class _InIt,
	class _FwdIt> inline
	_FwdIt uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest)
	{	
	_FwdIt _Next = _Dest;

	try {
	for (; _First != _Last; ++_Dest, ++_First)
		_Construct(&*_Dest, *_First);
	 } catch (...) {
	for (; _Next != _Dest; ++_Next)
		_Destroy(&*_Next);
	throw;
	}
	return (_Dest); }

		
template<class _InIt,
	class _FwdIt,
	class _Alloc> inline
	_FwdIt uninitialized_copy(_InIt _First, _InIt _Last,
		_FwdIt _Dest, _Alloc& _Al)
	{	
	return (_Uninit_copy(_First, _Last, _Dest,
		_Al, _Ptr_cat(_First, _Dest))); }

template<class _InIt,
	class _FwdIt,
	class _Alloc> inline
	_FwdIt _Uninit_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,
		_Alloc& _Al, _Nonscalar_ptr_iterator_tag)
	{	
	_FwdIt _Next = _Dest;

	try {
	for (; _First != _Last; ++_Dest, ++_First)
		_Al.construct(&*_Dest, *_First);
	 } catch (...) {
	for (; _Next != _Dest; ++_Next)
		_Al.destroy(&*_Next);
	throw;
	}
	return (_Dest); }

template<class _Ty> inline
	_Ty *_Uninit_copy(_Ty *_First, _Ty *_Last, _Ty *_Dest,
		allocator<_Ty>&, _Scalar_ptr_iterator_tag)
	{	
	size_t _Count = (size_t)(_Last - _First);
	return ((_Ty *)memmove(&*_Dest, &*_First,
		_Count * sizeof (*_First)) + _Count); }	

		
template<class _FwdIt,
	class _Tval> inline
	void uninitialized_fill(_FwdIt _First, _FwdIt _Last, const _Tval& _Val)
	{	
	_Uninit_fill(_First, _Last, _Val, _Ptr_cat(_First, _First)); }

template<class _FwdIt,
	class _Tval> inline
	void _Uninit_fill(_FwdIt _First, _FwdIt _Last, const _Tval& _Val,
		_Nonscalar_ptr_iterator_tag)
	{	
	_FwdIt _Next = _First;

	try {
	for (; _First != _Last; ++_First)
		_Construct(&*_First, _Val);
	 } catch (...) {
	for (; _Next != _First; ++_Next)
		_Destroy(&*_Next);
	throw;
	}}

template<class _Ty,
	class _Tval> inline
	void _Uninit_fill(_Ty *_First, _Ty *_Last, const _Tval& _Val,
		_Scalar_ptr_iterator_tag)
	{	
	fill(_First, _Last, _Val); }

		
template<class _FwdIt,
	class _Tval,
	class _Alloc> inline
	void uninitialized_fill(_FwdIt _First, _FwdIt _Last,
		const _Tval& _Val, _Alloc& _Al)
	{	
	_Uninit_fill(_First, _Last, _Val, _Al, _Ptr_cat(_First, _First)); }

template<class _FwdIt,
	class _Tval,
	class _Alloc> inline
	void _Uninit_fill(_FwdIt _First, _FwdIt _Last,
		const _Tval& _Val, _Alloc& _Al, _Nonscalar_ptr_iterator_tag)
	{	
	_FwdIt _Next = _First;

	try {
	for (; _First != _Last; ++_First)
		_Al.construct(&*_First, _Val);
	 } catch (...) {
	for (; _Next != _First; ++_Next)
		_Al.destroy(&*_Next);
	throw;
	}}

template<class _Ty,
	class _Tval> inline
	void _Uninit_fill(_Ty *_First, _Ty *_Last,
		const _Tval& _Val, allocator<_Ty>&, _Scalar_ptr_iterator_tag)
	{	
	fill(_First, _Last, _Val); }

		
template<class _FwdIt,
	class _Diff,
	class _Tval> inline
	void uninitialized_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val)
	{	
	_Uninit_fill_n(_First, _Count, _Val, _Ptr_cat(_First, _First)); }

template<class _FwdIt,
	class _Diff,
	class _Tval> inline
	void _Uninit_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val,
		_Nonscalar_ptr_iterator_tag)
	{	
	_FwdIt _Next = _First;

	try {
	for (; 0 < _Count; --_Count, ++_First)
		_Construct(&*_First, _Val);
	 } catch (...) {
	for (; _Next != _First; ++_Next)
		_Destroy(&*_Next);
	throw;
	}}

template<class _Ty,
	class _Diff,
	class _Tval> inline
	void _Uninit_fill_n(_Ty *_First, _Diff _Count, const _Tval& _Val,
		_Scalar_ptr_iterator_tag)
	{	
	fill_n(_First, _Count, _Val); }

		
template<class _FwdIt,
	class _Diff,
	class _Tval,
	class _Alloc> inline
	void uninitialized_fill_n(_FwdIt _First, _Diff _Count,
		const _Tval& _Val, _Alloc& _Al)
	{	
	_Uninit_fill_n(_First, _Count, _Val, _Al, _Ptr_cat(_First, _First)); }

template<class _FwdIt,
	class _Diff,
	class _Tval,
	class _Alloc> inline
	void _Uninit_fill_n(_FwdIt _First, _Diff _Count,
		const _Tval& _Val, _Alloc& _Al, _Nonscalar_ptr_iterator_tag)
	{	
	_FwdIt _Next = _First;

	try {
	for (; 0 < _Count; --_Count, ++_First)
		_Al.construct(&*_First, _Val);
	 } catch (...) {
	for (; _Next != _First; ++_Next)
		_Al.destroy(&*_Next);
	throw;
	}}

template<class _Ty,
	class _Diff,
	class _Tval> inline
	void _Uninit_fill_n(_Ty *_First, _Diff _Count,
		const _Tval& _Val, allocator<_Ty>&, _Scalar_ptr_iterator_tag)
	{	
	fill_n(_First, _Count, _Val); }

		
template<class _FwdIt,
	class _Ty>
	class raw_storage_iterator
		: public _Outit
	{	
public:
	typedef _FwdIt iter_type;
	typedef _Ty element_type;

	explicit raw_storage_iterator(_FwdIt _First)
		: _Next(_First)
		{}	

	raw_storage_iterator<_FwdIt, _Ty>& operator*()
		{	
		return (*this); }

	raw_storage_iterator<_FwdIt, _Ty>& operator=(const _Ty& _Val)
		{	
		_Construct(&*_Next, _Val);
		return (*this); }

	raw_storage_iterator<_FwdIt, _Ty>& operator++()
		{	
		++_Next;
		return (*this); }

	raw_storage_iterator<_FwdIt, _Ty> operator++(int)
		{	
		raw_storage_iterator<_FwdIt, _Ty> _Ans = *this;
		++_Next;
		return (_Ans); }

private:
	_FwdIt _Next;	
	};

		
template<class _Ty>
	class _Temp_iterator
		: public _Outit
	{	
public:
	typedef _Ty  *_Pty;

	_Temp_iterator(ptrdiff_t _Count = 0)
		{	
		pair<_Pty, ptrdiff_t> _Pair =
			get_temporary_buffer<_Ty>(_Count);
		_Buf._Begin = _Pair.first;
		_Buf._Current = _Pair.first;
		_Buf._Hiwater = _Pair.first;
		_Buf._Size = _Pair.second;
		_Pbuf = &_Buf; }

	_Temp_iterator(const _Temp_iterator<_Ty>& _Right)
		{	
		_Buf._Begin = 0;	
		_Buf._Current = 0;
		_Buf._Hiwater = 0;
		_Buf._Size = 0;
		*this = _Right; }

	~_Temp_iterator()
		{	
		if (_Buf._Begin != 0)
			{	
			for (_Pty _Next = _Buf._Begin;
				_Next != _Buf._Hiwater; ++_Next)
				_Destroy(&*_Next);
			return_temporary_buffer(_Buf._Begin); }}

	_Temp_iterator<_Ty>& operator=(const _Temp_iterator<_Ty>& _Right)
		{	
		_Pbuf = _Right._Pbuf;
		return (*this); }

	_Temp_iterator<_Ty>& operator=(const _Ty& _Val)
		{	
		if (_Pbuf->_Current < _Pbuf->_Hiwater)
			*_Pbuf->_Current++ = _Val;	
		else
			{	
			_Construct(&*_Pbuf->_Current, _Val);
			_Pbuf->_Hiwater = ++_Pbuf->_Current; }
		return (*this); }

	_Temp_iterator<_Ty>& operator*()
		{	
		return (*this); }

	_Temp_iterator<_Ty>& operator++()
		{	
		return (*this); }

	_Temp_iterator<_Ty>& operator++(int)
		{	
		return (*this); }

	_Temp_iterator<_Ty>& _Init()
		{	
		_Pbuf->_Current = _Pbuf->_Begin;
		return (*this); }

	_Pty _First() const
		{	
		return (_Pbuf->_Begin); }

	_Pty _Last() const
		{	
		return (_Pbuf->_Current); }

	ptrdiff_t _Maxlen() const
		{	
		return (_Pbuf->_Size); }

private:
	struct _Bufpar
		{	
		_Pty _Begin;	
		_Pty _Current;	
		_Pty _Hiwater;	
		ptrdiff_t _Size;	
		};
	_Bufpar _Buf;	
	_Bufpar *_Pbuf;	
	};

		
template<class _Ty>
	class auto_ptr
		{	
			
	template<class _Other>
		struct auto_ptr_ref
			{	
		auto_ptr_ref(auto_ptr<_Other>& _Right)
			: _Ref(_Right)
			{}	

		auto_ptr<_Other>& _Ref;	
		};

public:
	typedef _Ty element_type;

	explicit auto_ptr(_Ty *_Ptr = 0) throw ()
		: _Myptr(_Ptr)
		{}	

	auto_ptr(auto_ptr<_Ty>& _Right) throw ()
		: _Myptr(_Right.release())
		{}	

	auto_ptr(auto_ptr_ref<_Ty> _Right) throw ()
		: _Myptr(_Right._Ref.release())
		{}	

	template<class _Other>
		operator auto_ptr<_Other>() throw ()
		{	
		return (auto_ptr<_Other>(*this)); }

	template<class _Other>
		operator auto_ptr_ref<_Other>() throw ()
		{	
		return (auto_ptr_ref<_Other>(*this)); }

	template<class _Other>
		auto_ptr<_Ty>& operator=(auto_ptr<_Other>& _Right) throw ()
		{	
		reset(_Right.release());
		return (*this); }

	template<class _Other>
		auto_ptr(auto_ptr<_Other>& _Right) throw ()
		: _Myptr(_Right.release())
		{}	

	auto_ptr<_Ty>& operator=(auto_ptr<_Ty>& _Right) throw ()
		{	
		reset(_Right.release());
		return (*this); }

	~auto_ptr()
		{	
		delete _Myptr; }

	_Ty& operator*() const throw ()
		{	
		return (*get()); }

	_Ty *operator->() const throw ()
		{	
		return (get()); }

	_Ty *get() const throw ()
		{	
		return (_Myptr); }

	_Ty *release() throw ()
		{	
		_Ty *_Tmp = _Myptr;
		_Myptr = 0;
		return (_Tmp); }

	void reset(_Ty* _Ptr = 0)
		{	
		if (_Ptr != _Myptr)
			delete _Myptr;
		_Myptr = _Ptr; }

private:
	_Ty *_Myptr;	
	};

}	





 
















 
#line 6 "/usr/include/CC/list"
#line 1 "/usr/include/CC/stdexcept"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/stdexcept /main/1"




#line 1 "/usr/include/CC/exception"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/exception /main/1"

#line 7 "/usr/include/CC/stdexcept"
#line 1 "/usr/include/CC/xstring"





namespace std {

		
class _String_base
	{	
public:
	void _Xlen() const;	

	void _Xran() const;	
	};

		
template<class _Ty,
	class _Alloc>
	class _String_val
		: public _String_base
	{	
protected:
	typedef typename _Alloc::template
		rebind<_Ty>::other _Alty;

	_String_val(_Alty _Al = _Alty())
		: _Alval(_Al)
		{}	

	_Alty _Alval;	
	};

		
template<class _Elem,
	class _Traits = char_traits<_Elem>,
	class _Ax = allocator<_Elem> >
	class basic_string
		: public _String_val<_Elem, _Ax>
	{	
public:
	typedef basic_string<_Elem, _Traits, _Ax> _Myt;
	typedef _String_val<_Elem, _Ax> _Mybase;
	typedef typename _Mybase::_Alty _Alloc;
	typedef typename _Alloc::size_type size_type;
	typedef typename _Alloc::difference_type difference_type;
	typedef typename _Alloc::pointer _Tptr;
	typedef typename _Alloc::const_pointer _Ctptr;
	typedef _Tptr pointer;
	typedef _Ctptr const_pointer;
	typedef typename _Alloc::reference reference;
	typedef typename _Alloc::const_reference const_reference;
	typedef typename _Alloc::value_type value_type;
	typedef _Ptrit<value_type, difference_type, _Tptr,
		reference, _Tptr, reference> iterator;
	typedef _Ptrit<value_type, difference_type, _Ctptr,
		const_reference, _Tptr, reference> const_iterator;
	typedef std::reverse_iterator<iterator>
		reverse_iterator;
	typedef std::reverse_iterator<const_iterator>
		const_reverse_iterator;

	basic_string()
		: _Mybase()
		{	
		_Tidy(); }

	explicit basic_string(const _Alloc& _Al)
		: _Mybase(_Al)
		{	
		_Tidy(); }

	basic_string(const _Myt& _Right)
		: _Mybase(_Right._Alval)
		{	
		_Tidy(), assign(_Right, 0, npos); }

	basic_string(const _Myt& _Right, size_type _Roff,
		size_type _Count = npos)
		: _Mybase()
		{	
		_Tidy(), assign(_Right, _Roff, _Count); }

	basic_string(const _Myt& _Right, size_type _Roff, size_type _Count,
		const _Alloc& _Al)
		: _Mybase(_Al)
		{	
		_Tidy(), assign(_Right, _Roff, _Count); }

	basic_string(const _Elem *_Ptr, size_type _Count)
		: _Mybase()
		{	
		_Tidy(), assign(_Ptr, _Count); }

	basic_string(const _Elem *_Ptr, size_type _Count, const _Alloc& _Al)
		: _Mybase(_Al)
		{	
		_Tidy(), assign(_Ptr, _Count); }

	basic_string(const _Elem *_Ptr)
		: _Mybase()
		{	
		_Tidy(), assign(_Ptr); }

	basic_string(const _Elem *_Ptr, const _Alloc& _Al)
		: _Mybase(_Al)
		{	
		_Tidy(), assign(_Ptr); }

	basic_string(size_type _Count, _Elem _Char)
		: _Mybase()
		{	
		_Tidy(), assign(_Count, _Char); }

	basic_string(size_type _Count, _Elem _Char, const _Alloc& _Al)
		: _Mybase(_Al)
		{	
		_Tidy(), assign(_Count, _Char); }

	template<class _It>
		basic_string(_It _First, _It _Last)
		: _Mybase()
		{	
		_Construct(_First, _Last, _Iter_cat(_First)); }

	template<class _It>
		basic_string(_It _First, _It _Last, const _Alloc& _Al)
		: _Mybase(_Al)
		{	
		_Construct(_First, _Last, _Iter_cat(_First)); }

	template<class _It>
		void _Construct(_It _Count, _It _Char, _Int_iterator_tag)
		{	
		_Tidy(), assign((size_type)_Count, (_Elem)_Char); }

	template<class _It>
		void _Construct(_It _First, _It _Last, input_iterator_tag)
		{	
		_Tidy();
		for (; _First != _Last; ++_First)
			append((size_type)1, (_Elem)*_First); }

	template<class _It>
		void _Construct(_It _First, _It _Last, forward_iterator_tag)
		{	
		_Tidy();
		size_type _Count = 0;
		_Distance(_First, _Last, _Count);
		reserve(_Count);
		for (; _First != _Last; ++_First)
			append((size_type)1, (_Elem)*_First); }

	basic_string(const_pointer _First, const_pointer _Last)
		: _Mybase()
		{	
		_Tidy();
		if (_First != _Last)
			assign(&*_First, _Last - _First); }

	basic_string(const_iterator _First, const_iterator _Last)
		: _Mybase()
		{	
		_Tidy();
		if (_First != _Last)
			assign(&*_First, _Last - _First); }

	~basic_string()
		{	
		_Tidy(true); }

	typedef _Traits traits_type;
	typedef _Alloc allocator_type;

	static const size_type npos;	

	_Myt& operator=(const _Myt& _Right)
		{	
		return (assign(_Right)); }

	_Myt& operator=(const _Elem *_Ptr)
		{	
		return (assign(_Ptr)); }

	_Myt& operator=(_Elem _Char)
		{	
		return (assign(1, _Char)); }

	_Myt& operator+=(const _Myt& _Right)
		{	
		return (append(_Right)); }

	_Myt& operator+=(const _Elem *_Ptr)
		{	
		return (append(_Ptr)); }

	_Myt& operator+=(_Elem _Char)
		{	
		return (append((size_type)1, _Char)); }

	_Myt& append(const _Myt& _Right)
		{	
		return (append(_Right, 0, npos)); }

	_Myt& append(const _Myt& _Right, size_type _Roff, size_type _Count)
		{	
		if (_Right.size() < _Roff)
			_String_base::_Xran();	
		size_type _Num = _Right.size() - _Roff;
		if (_Num < _Count)
			_Count = _Num;	
		if (npos - _Mysize <= _Count)
			_String_base::_Xlen();	

		if (0 < _Count && _Grow(_Num = _Mysize + _Count))
			{	
			_Traits::copy(_Myptr() + _Mysize,
				_Right._Myptr() + _Roff, _Count);
			_Eos(_Num); }
		return (*this); }

	_Myt& append(const _Elem *_Ptr, size_type _Count)
		{	
		if (_Inside(_Ptr))
			return (append(*this, _Ptr - _Myptr(), _Count));	
		if (npos - _Mysize <= _Count)
			_String_base::_Xlen();	

		size_type _Num;
		if (0 < _Count && _Grow(_Num = _Mysize + _Count))
			{	
			_Traits::copy(_Myptr() + _Mysize, _Ptr, _Count);
			_Eos(_Num); }
		return (*this); }

	_Myt& append(const _Elem *_Ptr)
		{	
		return (append(_Ptr, _Traits::length(_Ptr))); }

	_Myt& append(size_type _Count, _Elem _Char)
		{	
		if (npos - _Mysize <= _Count)
			_String_base::_Xlen();	

		size_type _Num;
		if (0 < _Count && _Grow(_Num = _Mysize + _Count))
			{	
			_Traits::assign(_Myptr() + _Mysize, _Count, _Char);
			_Eos(_Num); }
		return (*this); }

	template<class _It>
		_Myt& append(_It _First, _It _Last)
		{	
		return (_Append(_First, _Last, _Iter_cat(_First))); }

	template<class _It>
		_Myt& _Append(_It _Count, _It _Char, _Int_iterator_tag)
		{	
		return (append((size_type)_Count, (_Elem)_Char)); }

	template<class _It>
		_Myt& _Append(_It _First, _It _Last, input_iterator_tag)
		{	
		return (replace(end(), end(), _First, _Last)); }

	_Myt& append(const_pointer _First, const_pointer _Last)
		{	
		return (replace(end(), end(), _First, _Last)); }

	_Myt& append(const_iterator _First, const_iterator _Last)
		{	
		return (replace(end(), end(), _First, _Last)); }

	_Myt& assign(const _Myt& _Right)
		{	
		return (assign(_Right, 0, npos)); }

	_Myt& assign(const _Myt& _Right, size_type _Roff, size_type _Count)
		{	
		if (_Right.size() < _Roff)
			_String_base::_Xran();	
		size_type _Num = _Right.size() - _Roff;
		if (_Count < _Num)
			_Num = _Count;	

		if (this == &_Right)
			erase((size_type)(_Roff + _Num)), erase(0, _Roff);	
		else if (_Grow(_Num, true))
			{	
			_Traits::copy(_Myptr(), _Right._Myptr() + _Roff, _Num);
			_Eos(_Num); }
		return (*this); }

	_Myt& assign(const _Elem *_Ptr, size_type _Num)
		{	
		if (_Inside(_Ptr))
			return (assign(*this, _Ptr - _Myptr(), _Num));	

		if (_Grow(_Num, true))
			{	
			_Traits::copy(_Myptr(), _Ptr, _Num);
			_Eos(_Num); }
		return (*this); }

	_Myt& assign(const _Elem *_Ptr)
		{	
		return (assign(_Ptr, _Traits::length(_Ptr))); }

	_Myt& assign(size_type _Count, _Elem _Char)
		{	
		if (_Count == npos)
			_String_base::_Xlen();	

		if (_Grow(_Count, true))
			{	
			_Traits::assign(_Myptr(), _Count, _Char);
			_Eos(_Count); }
		return (*this); }

	template<class _It>
		_Myt& assign(_It _First, _It _Last)
		{	
		return (_Assign(_First, _Last, _Iter_cat(_First))); }

	template<class _It>
		_Myt& _Assign(_It _Count, _It _Char, _Int_iterator_tag)
		{	
		return (assign((size_type)_Count, (_Elem)_Char)); }

	template<class _It>
		_Myt& _Assign(_It _First, _It _Last, input_iterator_tag)
		{	
		return (replace(begin(), end(), _First, _Last)); }

	_Myt& assign(const_pointer _First, const_pointer _Last)
		{	
		return (replace(begin(), end(), _First, _Last)); }

	_Myt& assign(const_iterator _First, const_iterator _Last)
		{	
		return (replace(begin(), end(), _First, _Last)); }

	_Myt& insert(size_type _Off, const _Myt& _Right)
		{	
		return (insert(_Off, _Right, 0, npos)); }

	_Myt& insert(size_type _Off, const _Myt& _Right, size_type _Roff,
		size_type _Count)
		{	
		if (_Mysize < _Off || _Right.size() < _Roff)
			_String_base::_Xran();	
		size_type _Num = _Right.size() - _Roff;
		if (_Num < _Count)
			_Count = _Num;	
		if (npos - _Mysize <= _Count)
			_String_base::_Xlen();	

		if (0 < _Count && _Grow(_Num = _Mysize + _Count))
			{	
			_Traits::move(_Myptr() + _Off + _Count,
				_Myptr() + _Off, _Mysize - _Off);	
			if (this == &_Right)
				_Traits::move(_Myptr() + _Off,
					_Myptr() + (_Off < _Roff ? _Roff + _Count : _Roff),
						_Count);	
			else
				_Traits::copy(_Myptr() + _Off,
					_Right._Myptr() + _Roff, _Count);	
			_Eos(_Num); }
		return (*this); }

	_Myt& insert(size_type _Off, const _Elem *_Ptr, size_type _Count)
		{	
		if (_Inside(_Ptr))
			return (insert(_Off, *this,
				_Ptr - _Myptr(), _Count));	
		if (_Mysize < _Off)
			_String_base::_Xran();	
		if (npos - _Mysize <= _Count)
			_String_base::_Xlen();	
		size_type _Num;
		if (0 < _Count && _Grow(_Num = _Mysize + _Count))
			{	
			_Traits::move(_Myptr() + _Off + _Count,
				_Myptr() + _Off, _Mysize - _Off);	
			_Traits::copy(_Myptr() + _Off, _Ptr, _Count);	
			_Eos(_Num); }
		return (*this); }

	_Myt& insert(size_type _Off, const _Elem *_Ptr)
		{	
		return (insert(_Off, _Ptr, _Traits::length(_Ptr))); }

	_Myt& insert(size_type _Off, size_type _Count, _Elem _Char)
		{	
		if (_Mysize < _Off)
			_String_base::_Xran();	
		if (npos - _Mysize <= _Count)
			_String_base::_Xlen();	
		size_type _Num;
		if (0 < _Count && _Grow(_Num = _Mysize + _Count))
			{	
			_Traits::move(_Myptr() + _Off + _Count,
				_Myptr() + _Off, _Mysize - _Off);	
			_Traits::assign(_Myptr() + _Off, _Count, _Char);	
			_Eos(_Num); }
		return (*this); }

	iterator insert(iterator _Where)
		{	
		return (insert(_Where, _Elem())); }

	iterator insert(iterator _Where, _Elem _Char)
		{	
		size_type _Off = _Pdif(_Where, begin());
		insert(_Off, 1, _Char);
		return (begin() + _Off); }

	void insert(iterator _Where, size_type _Count, _Elem _Char)
		{	
		size_type _Off = _Pdif(_Where, begin());
		insert(_Off, _Count, _Char); }

	template<class _It>
		void insert(iterator _Where, _It _First, _It _Last)
		{	
		_Insert(_Where, _First, _Last, _Iter_cat(_First)); }

	template<class _It>
		void _Insert(iterator _Where, _It _Count, _It _Char,
			_Int_iterator_tag)
		{	
		insert(_Where, (size_type)_Count, (_Elem)_Char); }

	template<class _It>
		void _Insert(iterator _Where, _It _First, _It _Last,
			input_iterator_tag)
		{	
		replace(_Where, _Where, _First, _Last); }

	void insert(iterator _Where, const_pointer _First, const_pointer _Last)
		{	
		replace(_Where, _Where, _First, _Last); }

	void insert(iterator _Where, const_iterator _First, const_iterator _Last)
		{	
		replace(_Where, _Where, _First, _Last); }

	_Myt& erase(size_type _Off = 0, size_type _Count = npos)
		{	
		if (_Mysize < _Off)
			_String_base::_Xran();	
		if (_Mysize - _Off < _Count)
			_Count = _Mysize - _Off;	
		if (0 < _Count)
			{	
			_Traits::move(_Myptr() + _Off, _Myptr() + _Off + _Count,
				_Mysize - _Off - _Count);
			size_type _Newsize = _Mysize - _Count;
			if (_Grow(_Newsize))
				_Eos(_Newsize); }
		return (*this); }

	iterator erase(iterator _Where)
		{	
		size_type _Count = _Pdif(_Where, begin());
		erase(_Count, 1);
		return (iterator(_Myptr() + _Count)); }

	iterator erase(iterator _First, iterator _Last)
		{	
		size_type _Count = _Pdif(_First, begin());
		erase(_Count, _Pdif(_Last, _First));
		return (iterator(_Myptr() + _Count)); }

	void clear()
		{	
		erase(begin(), end()); }

	_Myt& replace(size_type _Off, size_type _N0, const _Myt& _Right)
		{	
		return (replace(_Off, _N0, _Right, 0, npos)); }

	_Myt& replace(size_type _Off, size_type _N0, const _Myt& _Right,
		size_type _Roff, size_type _Count)
		{	
		if (_Mysize < _Off || _Right.size() < _Roff)
			_String_base::_Xran();	
		if (_Mysize - _Off < _N0)
			_N0 = _Mysize - _Off;	
		size_type _Num = _Right.size() - _Roff;
		if (_Num < _Count)
			_Count = _Num;	
		if (npos - _Count <= _Mysize - _N0)
			_String_base::_Xlen();	

		size_type _Nm = _Mysize - _N0 - _Off;	
		size_type _Newsize = _Mysize + _Count - _N0;
		if (_Mysize < _Newsize)
			_Grow(_Newsize);

		if (this != &_Right)
			{	
			_Traits::move(_Myptr() + _Off + _Count,
				_Myptr() + _Off + _N0, _Nm);	
			_Traits::copy(_Myptr() + _Off,
				_Right._Myptr() + _Roff, _Count); }	
		else if (_Count <= _N0)
			{	
			_Traits::move(_Myptr() + _Off,
				_Myptr() + _Roff, _Count);	
			_Traits::move(_Myptr() + _Off + _Count,
				_Myptr() + _Off + _N0, _Nm); }	
		else if (_Roff <= _Off)
			{	
			_Traits::move(_Myptr() + _Off + _Count,
				_Myptr() + _Off + _N0, _Nm);	
			_Traits::move(_Myptr() + _Off,
				_Myptr() + _Roff, _Count); }	
		else if (_Off + _N0 <= _Roff)
			{	
			_Traits::move(_Myptr() + _Off + _Count,
				_Myptr() + _Off + _N0, _Nm);	
			_Traits::move(_Myptr() + _Off,
				_Myptr() + (_Roff + _Count - _N0), _Count); }	
		else
			{	
			_Traits::move(_Myptr() + _Off,
				_Myptr() + _Roff, _N0);	
			_Traits::move(_Myptr() + _Off + _Count,
				_Myptr() + _Off + _N0, _Nm);	
			_Traits::move(_Myptr() + _Off + _N0, _Myptr() + _Roff + _Count,
				_Count - _N0); }	

		if (_Mysize < _Newsize || _Grow(_Newsize))
			_Eos(_Newsize);	
		return (*this); }

	_Myt& replace(size_type _Off, size_type _N0, const _Elem *_Ptr,
		size_type _Count)
		{	
		if (_Inside(_Ptr))
			return (replace(_Off, _N0, *this,
				_Ptr - _Myptr(), _Count));	
		if (_Mysize < _Off)
			_String_base::_Xran();	
		if (_Mysize - _Off < _N0)
			_N0 = _Mysize - _Off;	
		if (npos - _Count <= _Mysize - _N0)
			_String_base::_Xlen();	
		size_type _Nm = _Mysize - _N0 - _Off;

		if (_Count < _N0)
			_Traits::move(_Myptr() + _Off + _Count,
				_Myptr() + _Off + _N0, _Nm);	
		size_type _Num;
		if ((0 < _Count || 0 < _N0) && _Grow(_Num = _Mysize + _Count - _N0))
			{	
			if (_N0 < _Count)
				_Traits::move(_Myptr() + _Off + _Count,
					_Myptr() + _Off + _N0, _Nm);	
			_Traits::copy(_Myptr() + _Off, _Ptr, _Count);	
			_Eos(_Num); }
		return (*this); }

	_Myt& replace(size_type _Off, size_type _N0, const _Elem *_Ptr)
		{	
		return (replace(_Off, _N0, _Ptr, _Traits::length(_Ptr))); }

	_Myt& replace(size_type _Off, size_type _N0,
		size_type _Count, _Elem _Char)
		{	
		if (_Mysize < _Off)
			_String_base::_Xran();	
		if (_Mysize - _Off < _N0)
			_N0 = _Mysize - _Off;	
		if (npos - _Count <= _Mysize - _N0)
			_String_base::_Xlen();	
		size_type _Nm = _Mysize - _N0 - _Off;

		if (_Count < _N0)
			_Traits::move(_Myptr() + _Off + _Count,
				_Myptr() + _Off + _N0, _Nm);	
		size_type _Num;
		if ((0 < _Count || 0 < _N0) && _Grow(_Num = _Mysize + _Count - _N0))
			{	
			if (_N0 < _Count)
				_Traits::move(_Myptr() + _Off + _Count,
					_Myptr() + _Off + _N0, _Nm);	
			_Traits::assign(_Myptr() + _Off, _Count, _Char);	
			_Eos(_Num); }
		return (*this); }

	_Myt& replace(iterator _First, iterator _Last, const _Myt& _Right)
		{	
		return (replace(
			_Pdif(_First, begin()), _Pdif(_Last, _First), _Right)); }

	_Myt& replace(iterator _First, iterator _Last, const _Elem *_Ptr,
		size_type _Count)
		{	
		return (replace(
			_Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr, _Count)); }

	_Myt& replace(iterator _First, iterator _Last, const _Elem *_Ptr)
		{	
		return (replace(
			_Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr)); }

	_Myt& replace(iterator _First, iterator _Last,
		size_type _Count, _Elem _Char)
		{	
		return (replace(
			_Pdif(_First, begin()), _Pdif(_Last, _First), _Count, _Char)); }

	template<class _It>
		_Myt& replace(iterator _First, iterator _Last,
			_It _First2, _It _Last2)
		{	
		return (_Replace(_First, _Last,
			_First2, _Last2, _Iter_cat(_First2))); }

	template<class _It>
		_Myt& _Replace(iterator _First, iterator _Last,
			_It _Count, _It _Char, _Int_iterator_tag)
		{	
		return (replace(_First, _Last, (size_type)_Count, (_Elem)_Char)); }

	template<class _It>
		_Myt& _Replace(iterator _First, iterator _Last,
			_It _First2, _It _Last2, input_iterator_tag)
		{	
		_Myt _Right(_First2, _Last2);
		replace(_First, _Last, _Right);
		return (*this); }

	_Myt& replace(iterator _First, iterator _Last,
		const_pointer _First2, const_pointer _Last2)
		{	
		if (_First2 == _Last2)
			erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
		else
			replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
				&*_First2, _Last2 - _First2);
		return (*this); }

	_Myt& replace(iterator _First, iterator _Last,
		const_iterator _First2, const_iterator _Last2)
		{	
		if (_First2 == _Last2)
			erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
		else
			replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
				&*_First2, _Last2 - _First2);
		return (*this); }

	iterator begin()
		{	
		return (iterator(_Myptr())); }

	const_iterator begin() const
		{	
		return (const_iterator(_Myptr())); }

	iterator end()
		{	
		return (iterator(_Myptr() + _Mysize)); }

	const_iterator end() const
		{	
		return (const_iterator(_Myptr() + _Mysize)); }

	reverse_iterator rbegin()
		{	
		return (reverse_iterator(end())); }

	const_reverse_iterator rbegin() const
		{	
		return (const_reverse_iterator(end())); }

	reverse_iterator rend()
		{	
		return (reverse_iterator(begin())); }

	const_reverse_iterator rend() const
		{	
		return (const_reverse_iterator(begin())); }

	reference at(size_type _Off)
		{	
		if (_Mysize <= _Off)
			_String_base::_Xran();	
		return (_Myptr()[_Off]); }

	const_reference at(size_type _Off) const
		{	
		if (_Mysize <= _Off)
			_String_base::_Xran();	
		return (_Myptr()[_Off]); }

	reference operator[](size_type _Off)
		{	
		return (_Myptr()[_Off]); }

	const_reference operator[](size_type _Off) const
		{	
		return (_Myptr()[_Off]); }

	void push_back(_Elem _Char)
		{	
		insert(end(), _Char); }

	const _Elem *c_str() const
		{	
		return (_Myptr()); }

	const _Elem *data() const
		{	
		return (c_str()); }

	size_type length() const
		{	
		return (_Mysize); }

	size_type size() const
		{	
		return (_Mysize); }

	size_type max_size() const
		{	
		size_type _Num = _Mybase::_Alval.max_size();
		return (_Num <= 1 ? 1 : _Num - 1); }

	void resize(size_type _Newsize)
		{	
		resize(_Newsize, _Elem()); }

	void resize(size_type _Newsize, _Elem _Char)
		{	
		if (_Newsize <= _Mysize)
			erase(_Newsize);
		else
			append(_Newsize - _Mysize, _Char); }

	size_type capacity() const
		{	
		return (_Myres); }

	void reserve(size_type _Newcap = 0)
		{	
		if (_Myres < _Newcap)
			_Grow(_Newcap); }

	bool empty() const
		{	
		return (_Mysize == 0); }

	size_type copy(_Elem *_Ptr, size_type _Count, size_type _Off = 0) const
		{	
		if (_Mysize < _Off)
			_String_base::_Xran();	
		if (_Mysize - _Off < _Count)
			_Count = _Mysize - _Off;
		_Traits::copy(_Ptr, _Myptr() + _Off, _Count);
		return (_Count); }

	void swap(_Myt& _Right)
		{	
		if (_Mybase::_Alval == _Right._Alval)
			{	
			_Bxty _Tbx = _Bx;
			_Bx = _Right._Bx, _Right._Bx = _Tbx;

			size_type _Tlen = _Mysize;
			_Mysize = _Right._Mysize, _Right._Mysize = _Tlen;

			size_type _Tres = _Myres;
			_Myres = _Right._Myres, _Right._Myres = _Tres; }
		else
			{	
			_Myt _Tmp = *this; *this = _Right, _Right = _Tmp; }}

	size_type find(const _Myt& _Right, size_type _Off = 0) const
		{	
		return (find(_Right._Myptr(), _Off, _Right.size())); }

	size_type find(const _Elem *_Ptr, size_type _Off,
		size_type _Count) const
		{	
		if (_Count == 0 && _Off <= _Mysize)
			return (_Off);	

		size_type _Nm;
		if (_Off < _Mysize && _Count <= (_Nm = _Mysize - _Off))
			{	
			const _Elem *_Uptr, *_Vptr;
			for (_Nm -= _Count - 1, _Vptr = _Myptr() + _Off;
				(_Uptr = _Traits::find(_Vptr, _Nm, *_Ptr)) != 0;
				_Nm -= _Uptr - _Vptr + 1, _Vptr = _Uptr + 1)
				if (_Traits::compare(_Uptr, _Ptr, _Count) == 0)
					return (_Uptr - _Myptr()); }	

		return (npos); }	

	size_type find(const _Elem *_Ptr, size_type _Off = 0) const
		{	
		return (find(_Ptr, _Off, _Traits::length(_Ptr))); }

	size_type find(_Elem _Char, size_type _Off = 0) const
		{	
		return (find((const _Elem *)&_Char, _Off, 1)); }

	size_type rfind(const _Myt& _Right, size_type _Off = npos) const
		{	
		return (rfind(_Right._Myptr(), _Off, _Right.size())); }

	size_type rfind(const _Elem *_Ptr, size_type _Off,
		size_type _Count) const
		{	
		if (_Count == 0)
			return (_Off < _Mysize ? _Off : _Mysize);	
		if (_Count <= _Mysize)
			{	
			const _Elem *_Uptr = _Myptr() +
				(_Off < _Mysize - _Count ? _Off : _Mysize - _Count);
			for (; ; --_Uptr)
				if (_Traits::eq(*_Uptr, *_Ptr)
					&& _Traits::compare(_Uptr, _Ptr, _Count) == 0)
					return (_Uptr - _Myptr());	
				else if (_Uptr == _Myptr())
					break; }	

		return (npos); }	

	size_type rfind(const _Elem *_Ptr, size_type _Off = npos) const
		{	
		return (rfind(_Ptr, _Off, _Traits::length(_Ptr))); }

	size_type rfind(_Elem _Char, size_type _Off = npos) const
		{	
		return (rfind((const _Elem *)&_Char, _Off, 1)); }

	size_type find_first_of(const _Myt& _Right,
		size_type _Off = 0) const
		{	
		return (find_first_of(_Right._Myptr(), _Off, _Right.size())); }

	size_type find_first_of(const _Elem *_Ptr, size_type _Off,
		size_type _Count) const
		{	
		if (0 < _Count && _Off < _Mysize)
			{	
			const _Elem *const _Vptr = _Myptr() + _Mysize;
			for (const _Elem *_Uptr = _Myptr() + _Off; _Uptr < _Vptr; ++_Uptr)
				if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
					return (_Uptr - _Myptr()); }	

		return (npos); }	

	size_type find_first_of(const _Elem *_Ptr, size_type _Off = 0) const
		{	
		return (find_first_of(_Ptr, _Off, _Traits::length(_Ptr))); }

	size_type find_first_of(_Elem _Char, size_type _Off = 0) const
		{	
		return (find((const _Elem *)&_Char, _Off, 1)); }

	size_type find_last_of(const _Myt& _Right,
		size_type _Off = npos) const
		{	
		return (find_last_of(_Right._Myptr(), _Off, _Right.size())); }

	size_type find_last_of(const _Elem *_Ptr, size_type _Off,
		size_type _Count) const
		{	
		if (0 < _Count && 0 < _Mysize)
			for (const _Elem *_Uptr = _Myptr()
				+ (_Off < _Mysize ? _Off : _Mysize - 1); ; --_Uptr)
				if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
					return (_Uptr - _Myptr());	
				else if (_Uptr == _Myptr())
					break;	

		return (npos); }	

	size_type find_last_of(const _Elem *_Ptr,
		size_type _Off = npos) const
		{	
		return (find_last_of(_Ptr, _Off, _Traits::length(_Ptr))); }

	size_type find_last_of(_Elem _Char, size_type _Off = npos) const
		{	
		return (rfind((const _Elem *)&_Char, _Off, 1)); }

	size_type find_first_not_of(const _Myt& _Right,
		size_type _Off = 0) const
		{	
		return (find_first_not_of(_Right._Myptr(), _Off,
			_Right.size())); }

	size_type find_first_not_of(const _Elem *_Ptr, size_type _Off,
		size_type _Count) const
		{	
		if (_Off < _Mysize)
			{	
			const _Elem *const _Vptr = _Myptr() + _Mysize;
			for (const _Elem *_Uptr = _Myptr() + _Off; _Uptr < _Vptr; ++_Uptr)
				if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
					return (_Uptr - _Myptr()); }
		return (npos); }

	size_type find_first_not_of(const _Elem *_Ptr,
		size_type _Off = 0) const
		{	
		return (find_first_not_of(_Ptr, _Off, _Traits::length(_Ptr))); }

	size_type find_first_not_of(_Elem _Char, size_type _Off = 0) const
		{	
		return (find_first_not_of((const _Elem *)&_Char, _Off, 1)); }

	size_type find_last_not_of(const _Myt& _Right,
		size_type _Off = npos) const
		{	
		return (find_last_not_of(_Right._Myptr(), _Off, _Right.size())); }

	size_type find_last_not_of(const _Elem *_Ptr, size_type _Off,
		size_type _Count) const
		{	
		if (0 < _Mysize)
			for (const _Elem *_Uptr = _Myptr()
				+ (_Off < _Mysize ? _Off : _Mysize - 1); ; --_Uptr)
				if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
					return (_Uptr - _Myptr());
				else if (_Uptr == _Myptr())
					break;
		return (npos); }

	size_type find_last_not_of(const _Elem *_Ptr,
		size_type _Off = npos) const
		{	
		return (find_last_not_of(_Ptr, _Off, _Traits::length(_Ptr))); }

	size_type find_last_not_of(_Elem _Char, size_type _Off = npos) const
		{	
		return (find_last_not_of((const _Elem *)&_Char, _Off, 1)); }

	_Myt substr(size_type _Off = 0, size_type _Count = npos) const
		{	
		return (_Myt(*this, _Off, _Count)); }

	int compare(const _Myt& _Right) const
		{	
		return (compare(0, _Mysize, _Right._Myptr(), _Right.size())); }

	int compare(size_type _Off, size_type _N0,
		const _Myt& _Right) const
		{	
		return (compare(_Off, _N0, _Right, 0, npos)); }

	int compare(size_type _Off, size_type _N0, const _Myt& _Right,
		size_type _Roff, size_type _Count) const
		{	
		if (_Right.size() < _Roff)
			_String_base::_Xran();	
		if (_Right._Mysize - _Roff < _Count)
			_Count = _Right._Mysize - _Roff;	
		return (compare(_Off, _N0, _Right._Myptr() + _Roff, _Count)); }

	int compare(const _Elem *_Ptr) const
		{	
		return (compare(0, _Mysize, _Ptr, _Traits::length(_Ptr))); }

	int compare(size_type _Off, size_type _N0, const _Elem *_Ptr) const
		{	
		return (compare(_Off, _N0, _Ptr, _Traits::length(_Ptr))); }

	int compare(size_type _Off, size_type _N0, const _Elem *_Ptr,
		size_type _Count) const
		{	
		if (_Mysize < _Off)
			_String_base::_Xran();	
		if (_Mysize - _Off < _N0)
			_N0 = _Mysize - _Off;	

		size_type _Ans = _N0 == 0 ? 0
			: _Traits::compare(_Myptr() + _Off, _Ptr,
				_N0 < _Count ? _N0 : _Count);
		return (_Ans != 0 ? _Ans : _N0 < _Count ? -1
			: _N0 == _Count ? 0 : +1); }

	allocator_type get_allocator() const
		{	
		return (_Mybase::_Alval); }

	enum
		{	
		_BUF_SIZE = 16 / sizeof (_Elem) < 1 ? 1
			: 16 / sizeof(_Elem)};
private:
	enum
		{	
		_ALLOC_MASK = sizeof (_Elem) <= 1 ? 15
			: sizeof (_Elem) <= 2 ? 7
			: sizeof (_Elem) <= 4 ? 3
			: sizeof (_Elem) <= 8 ? 1 : 0};

	void _Copy(size_type _Newsize, size_type _Oldlen)
		{	
		size_type _Newres = _Newsize | _ALLOC_MASK;
		if (max_size() < _Newres)
			_Newres = _Newsize;	
		_Elem *_Ptr;

		try {
			_Ptr = _Mybase::_Alval.allocate(_Newres + 1, (void *)0);
		 } catch (...) {
			_Newres = _Newsize;	
			_Ptr = _Mybase::_Alval.allocate(_Newres + 1, (void *)0);
		}

		if (0 < _Oldlen)
			_Traits::copy(_Ptr, _Myptr(), _Oldlen);	
		_Tidy(true);
		_Bx._Ptr = _Ptr;
		_Myres = _Newres;
		_Eos(_Oldlen); }

	void _Eos(size_type _Newsize)
		{	
		_Traits::assign(_Myptr()[_Mysize = _Newsize], _Elem()); }

	bool _Grow(size_type _Newsize, bool _Trim = false)
		{	
		if (max_size() < _Newsize)
			_String_base::_Xlen();	
		if (_Myres < _Newsize)
			_Copy(_Newsize, _Trim ? 0 : _Mysize);	
		else if (_Trim && _Newsize < _BUF_SIZE)
			_Tidy(true);	
		else if (_Newsize == 0)
			_Eos(0);	
		return (0 < _Newsize); }	

	bool _Inside(const _Elem *_Ptr)
		{	
		return (_Myptr() <= _Ptr && _Ptr < _Myptr() + _Mysize); }

	static size_type _Pdif(const_iterator _P2,
		const_iterator _P1)
		{	
		return (_P2.base() == 0 ? 0 : _P2 - _P1); }

	_Elem *_Myptr()
		{	
		return (_BUF_SIZE <= _Myres ? _Bx._Ptr : _Bx._Buf); }

	const _Elem *_Myptr() const
		{	
		return (_BUF_SIZE <= _Myres ? _Bx._Ptr : _Bx._Buf); }

	void _Tidy(bool _Built = false)
		{	
		if (!_Built)
			;
		else if (_BUF_SIZE <= _Myres)
			_Mybase::_Alval.deallocate(_Myptr(), _Myres + 1);
		_Myres = _BUF_SIZE - 1;
		_Eos(0); }

	union _Bxty
		{	
		_Elem _Buf[_BUF_SIZE];
		_Elem *_Ptr;
		} _Bx;

	size_type _Mysize;	
	size_type _Myres;	
	};

		
template<class _Elem,
	class _Traits,
	class _Alloc>
	const   basic_string<_Elem, _Traits, _Alloc>::size_type
		basic_string<_Elem, _Traits, _Alloc>::npos =
			(basic_string<_Elem, _Traits, _Alloc>::size_type)(-1);

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	void swap(basic_string<_Elem, _Traits, _Alloc>& _Left,
		basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	_Left.swap(_Right); }

typedef basic_string<char, char_traits<char>, allocator<char> >
	string;
typedef basic_string<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wstring;

}	





 
#line 8 "/usr/include/CC/stdexcept"

namespace std {

  class logic_error : public exception {
  public:
    explicit logic_error(const string&);
  };

  class domain_error : public logic_error {
  public:
    explicit domain_error(const string&);
  };

  class invalid_argument : public logic_error {
  public:
    explicit invalid_argument(const string&);
  };

  class length_error : public logic_error {
  public:
    explicit length_error(const string&);
  };

  class out_of_range : public logic_error {
  public:
    explicit out_of_range(const string&);
  };

  class runtime_error : public exception {
  public:
    explicit runtime_error(const string&);
  };

  class range_error : public runtime_error {
  public:
    explicit range_error(const string&);
  };

  class underflow_error : public runtime_error {
  public:
    explicit underflow_error(const string&);
  };

  class overflow_error : public runtime_error {
  public:
    explicit overflow_error(const string&);
  };

}

#line 7 "/usr/include/CC/list"

namespace std {

		
template<class _Ty,
	class _Alloc>
	class _List_nod
	{	
protected:
	typedef typename _Alloc::template
		rebind<void>::other::pointer _Genptr;

	struct _Node;
	friend struct _Node;
	struct _Node
		{	
		_Genptr _Next;	
		_Genptr _Prev;	
		_Ty _Myval;	
		};

	_List_nod(_Alloc _Al)
		: _Alnod(_Al) 
		{}	

	typename _Alloc::template rebind<_Node>::other
		_Alnod;	
	};

		
template<class _Ty,
	class _Alloc>
	class _List_ptr
		: public _List_nod<_Ty, _Alloc>
	{	
protected:
	typedef typename _List_nod<_Ty, _Alloc>::_Node _Node;
	typedef typename _Alloc::template
		rebind<_Node>::other::pointer _Nodeptr;

	_List_ptr(_Alloc _Al)
		: _List_nod<_Ty, _Alloc>(_Al), _Alptr(_Al)
		{}	

	typename _Alloc::template rebind<_Nodeptr>::other
		_Alptr;	
	};

		
template<class _Ty,
	class _Alloc>
	class _List_val
		: public _List_ptr<_Ty, _Alloc>
	{	
protected:
	typedef typename _Alloc::template rebind<_Ty>::other _Alty;

	_List_val(_Alloc _Al = _Alloc())
		: _List_ptr<_Ty, _Alloc>(_Al), _Alval(_Al)
		{}	

	_Alty _Alval;	
	};

		
template<class _Ty,
	class _Ax = allocator<_Ty> >
	class list
		: public _List_val<_Ty, _Ax>
	{	
public:
	typedef list<_Ty, _Ax> _Myt;
	typedef _List_val<_Ty, _Ax> _Mybase;
	typedef typename _Mybase::_Alty _Alloc;

protected:
	typedef typename _List_nod<_Ty, _Alloc>::_Genptr _Genptr;
	typedef typename _List_nod<_Ty, _Alloc>::_Node _Node;
	typedef typename _Alloc::template rebind<_Node> ::other::pointer _Nodeptr;
	typedef typename _Alloc::template rebind<_Nodeptr> ::other::reference _Nodepref;
	typedef typename _Alloc::reference _Vref;

	static _Nodepref _Next(_Nodeptr _Pnode)
		{	
		return ((_Nodepref)(*_Pnode)._Next); }

	static _Nodepref _Prev(_Nodeptr _Pnode)
		{	
		return ((_Nodepref)(*_Pnode)._Prev); }

	static _Vref _Myval(_Nodeptr _Pnode)
		{	
		return ((_Vref)(*_Pnode)._Myval); }

public:
	typedef _Alloc allocator_type;
	typedef typename _Alloc::size_type size_type;
	typedef typename _Alloc::difference_type _Dift;
	typedef _Dift difference_type;
	typedef typename _Alloc::pointer _Tptr;
	typedef typename _Alloc::const_pointer _Ctptr;
	typedef _Tptr pointer;
	typedef _Ctptr const_pointer;
	typedef typename _Alloc::reference _Reft;
	typedef _Reft reference;
	typedef typename _Alloc::const_reference const_reference;
	typedef typename _Alloc::value_type value_type;

		
	class const_iterator;
	friend class const_iterator;

	class const_iterator
		: public _Bidit<_Ty, _Dift, _Ctptr, const_reference>
		{	
	public:
		typedef bidirectional_iterator_tag iterator_category;
		typedef _Ty value_type;
		typedef _Dift difference_type;
		typedef _Ctptr pointer;
		typedef const_reference reference;

		const_iterator()
			: _Ptr(0)
			{}	

		const_iterator(_Nodeptr _Pnode)
			: _Ptr(_Pnode)
			{}	

		const_reference operator*() const
			{	
			return (_Myval(_Ptr)); }

		_Ctptr operator->() const
			{	
			return (&**this); }

		const_iterator& operator++()
			{	
			_Ptr = _Next(_Ptr);
			return (*this); }

		const_iterator operator++(int)
			{	
			const_iterator _Tmp = *this;
			++*this;
			return (_Tmp); }

		const_iterator& operator--()
			{	
			_Ptr = _Prev(_Ptr);
			return (*this); }

		const_iterator operator--(int)
			{	
			const_iterator _Tmp = *this;
			--*this;
			return (_Tmp); }

		bool operator==(const const_iterator& _Right) const
			{	
			return (_Ptr == _Right._Ptr); }

		bool operator!=(const const_iterator& _Right) const
			{	
			return (!(*this == _Right)); }

		_Nodeptr _Mynode() const
			{	
			return (_Ptr); }

	protected:
		_Nodeptr _Ptr;	
		};

		
	class iterator;
	friend class iterator;

	class iterator
		: public const_iterator
		{	
	public:
		typedef bidirectional_iterator_tag iterator_category;
		typedef _Ty value_type;
		typedef _Dift difference_type;
		typedef _Tptr pointer;
		typedef _Reft reference;

		iterator()
			: const_iterator(0)
			{}	

		iterator(_Nodeptr _Pnode)
			: const_iterator(_Pnode)
			{}	

		reference operator*() const
			{	
			return (_Myval(_Ptr)); }


		_Tptr operator->() const
			{	
			return (&**this); }

		iterator& operator++()
			{	
			_Ptr = _Next(_Ptr);
			return (*this); }

		iterator operator++(int)
			{	
			iterator _Tmp = *this;
			++*this;
			return (_Tmp); }

		iterator& operator--()
			{	
			_Ptr = _Prev(_Ptr);
			return (*this); }

		iterator operator--(int)
			{	
			iterator _Tmp = *this;
			--*this;
			return (_Tmp); }
		};

	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	list()
		: _Mybase(), _Head(_Buynode()), _Mysize(0)
		{}	

	explicit list(const _Alloc& _Al)
		: _Mybase(_Al), _Head(_Buynode()), _Mysize(0)
		{}	

	explicit list(size_type _Count)
		: _Mybase(), _Head(_Buynode()), _Mysize(0)
		{	
		insert(begin(), _Count, _Ty()); }

	list(size_type _Count, const _Ty& _Val)
		: _Mybase(), _Head(_Buynode()), _Mysize(0)
		{	
		insert(begin(), _Count, _Val); }

	list(size_type _Count, const _Ty& _Val, const _Alloc& _Al)
		: _Mybase(_Al), _Head(_Buynode()), _Mysize(0)
		{	
		insert(begin(), _Count, _Val); }

	list(const _Myt& _Right)
		: _Mybase(_Right._Alval),
			_Head(_Buynode()), _Mysize(0)
		{	
		insert(begin(), _Right.begin(), _Right.end()); }

	template<class _Iter>
		list(_Iter _First, _Iter _Last)
		: _Mybase(), _Head(_Buynode()), _Mysize(0)
		{	
		_Construct(_First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		list(_Iter _First, _Iter _Last, const _Alloc& _Al)
		: _Mybase(_Al), _Head(_Buynode()), _Mysize(0)
		{	
		_Construct(_First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		void _Construct(_Iter _Count, _Iter _Val, _Int_iterator_tag)
		{	
		insert(begin(), (size_type)_Count, (_Ty)_Val); }

	template<class _Iter>
		void _Construct(_Iter _First, _Iter _Last, input_iterator_tag)
		{	
		insert(begin(), _First, _Last); }

	~list()
		{	
		erase(begin(), end());
		_Freenode(_Head);
		_Head = 0, _Mysize = 0; }

	_Myt& operator=(const _Myt& _Right)
		{	
		if (this != &_Right)
			assign(_Right.begin(), _Right.end());
		return (*this); }

	iterator begin()
		{	
		return (iterator(_Head == 0 ? 0 : _Next(_Head))); }

	const_iterator begin() const
		{	
		return (const_iterator(_Head == 0 ? 0 : _Next(_Head))); }

	iterator end()
		{	
		return (iterator(_Head)); }

	const_iterator end() const
		{	
		return (const_iterator(_Head)); }

	reverse_iterator rbegin()
		{	
		return (reverse_iterator(end())); }

	const_reverse_iterator rbegin() const
		{	
		return (const_reverse_iterator(end())); }

	reverse_iterator rend()
		{	
		return (reverse_iterator(begin())); }

	const_reverse_iterator rend() const
		{	
		return (const_reverse_iterator(begin())); }

	void resize(size_type _Newsize)
		{	
		resize(_Newsize, _Ty()); }

	void resize(size_type _Newsize, _Ty _Val)
		{	
		if (size() < _Newsize)
			insert(end(), _Newsize - size(), _Val);
		else
			while (_Newsize < size())
				pop_back(); }

	size_type size() const
		{	
		return (_Mysize); }

	size_type max_size() const
		{	
		return (_Mybase::_Alval.max_size()); }

	bool empty() const
		{	
		return (_Mysize == 0); }

	allocator_type get_allocator() const
		{	
		return (_Mybase::_Alval); }

	reference front()
		{	
		return (*begin()); }

	const_reference front() const
		{	
		return (*begin()); }

	reference back()
		{	
		return (*(--end())); }

	const_reference back() const
		{	
		return (*(--end())); }

	void push_front(const _Ty& _Val)
		{	
		_Insert(begin(), _Val); }

	void pop_front()
		{	
		erase(begin()); }

	void push_back(const _Ty& _Val)
		{	
		_Insert(end(), _Val); }

	void pop_back()
		{	
		erase(--end()); }

	template<class _Iter>
		void assign(_Iter _First, _Iter _Last)
		{	
		_Assign(_First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		void _Assign(_Iter _Count, _Iter _Val, _Int_iterator_tag)
		{	
		assign((size_type)_Count, (_Ty)_Val); }

	template<class _Iter>
		void _Assign(_Iter _First, _Iter _Last, input_iterator_tag)
		{	
		erase(begin(), end());
		insert(begin(), _First, _Last); }

	void assign(size_type _Count, const _Ty& _Val)
		{	
		_Ty _Tmp = _Val;	
		erase(begin(), end());
		insert(begin(), _Count, _Tmp); }

	iterator insert(iterator _Where, const _Ty& _Val)
		{	
		_Insert(_Where, _Val);
		return (--_Where); }

	void _Insert(iterator _Where, const _Ty& _Val)
		{	
		_Nodeptr _Pnode = _Where._Mynode();
		_Nodeptr _Newnode = 0;

		try {
		_Incsize(1);
		_Newnode = _Buynode(_Pnode, _Prev(_Pnode));
		_Mybase::_Alval.construct(&_Myval(_Newnode), _Val);
		 } catch (...) {
		if (_Newnode != 0)
			{	
			--_Mysize;
			_Freenode(_Newnode); }
		throw;
		}

		_Prev(_Pnode) = _Newnode;
		_Next(_Prev(_Newnode)) = _Newnode; }

	void insert(iterator _Where, size_type _Count, const _Ty& _Val)
		{	
		size_type _Countsave = _Count;

		try {
		for (; 0 < _Count; --_Count)
			_Insert(_Where, _Val);
		 } catch (...) {
		for (; _Count < _Countsave; ++_Count)
			{	
			iterator _Before = _Where;
			erase(--_Before); }
		throw;
		}}

	template<class _Iter>
		void insert(iterator _Where, _Iter _First, _Iter _Last)
		{	
		_Insert(_Where, _First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		void _Insert(iterator _Where, _Iter _Count, _Iter _Val,
			_Int_iterator_tag)
		{	
		insert(_Where, (size_type)_Count, (_Ty)_Val); }

	template<class _Iter>
		void _Insert(iterator _Where, _Iter _First, _Iter _Last,
			input_iterator_tag)
		{	
		size_type _Num = 0;

		try {
		for (; _First != _Last; ++_First, ++_Num)
			_Insert(_Where, *_First);
		 } catch (...) {
		for (; 0 < _Num; --_Num)
			{	
			iterator _Before = _Where;
			erase(--_Before); }
		throw;
		}}

	template<class _Iter>
		void _Insert(iterator _Where, _Iter _First, _Iter _Last,
			forward_iterator_tag)
		{	
		_Iter _Next = _First;

		try {
		for (; _First != _Last; ++_First)
			_Insert(_Where, *_First);
		 } catch (...) {
		for (; _Next != _First; ++_Next)
			{	
			iterator _Before = _Where;
			erase(--_Before); }
		throw;
		}}

	iterator erase(iterator _Where)
		{	
		_Nodeptr _Pnode = (_Where++)._Mynode();
		if (_Pnode != _Head)
			{	
			_Next(_Prev(_Pnode)) = _Next(_Pnode);
			_Prev(_Next(_Pnode)) = _Prev(_Pnode);
			_Mybase::_Alval.destroy(&_Myval(_Pnode));
			_Freenode(_Pnode);
			--_Mysize; }
		return (_Where); }

	iterator erase(iterator _First, iterator _Last)
		{	
		while (_First != _Last)
			erase(_First++);
		return (_First); }

	void clear()
		{	
		erase(begin(), end()); }

	void swap(_Myt& _Right)
		{	
		if (_Mybase::_Alval == _Right._Alval)
			{	
			std::swap(_Head, _Right._Head);
			std::swap(_Mysize, _Right._Mysize); }
		else
			{	
			iterator _Where = begin();
			splice(_Where, _Right);
			_Right.splice(_Right.begin(), *this, _Where, end()); }}

	void splice(iterator _Where, _Myt& _Right)
		{	
		if (this != &_Right && !_Right.empty())
			{	
			_Splice(_Where, _Right, _Right.begin(), _Right.end(),
				_Right._Mysize); }}

	void splice(iterator _Where, _Myt& _Right, iterator _First)
		{	
		iterator _Last = _First;
		if (_First != _Right.end() && _Where != _First && _Where != ++_Last)
			{	
			_Splice(_Where, _Right, _First, _Last, 1); }}

	void splice(iterator _Where, _Myt& _Right,
		iterator _First, iterator _Last)
		{	
		if (_First != _Last && _Where != _Last)
			{	
			size_type _Count = 0;
			if (this == &_Right)
				;	
			else if (_First == _Right.begin() && _Last == _Right.end())
				_Count = _Right.size();	
			else
				_Distance(_First, _Last, _Count);	
			_Splice(_Where, _Right, _First, _Last, _Count); }}

	void remove(const _Ty& _Val)
		{	
		iterator _Last = end();
		for (iterator _First = begin(); _First != _Last; )
			if (*_First == _Val)
				erase(_First++);
			else
				++_First; }

	template<class _Pr1>
		void remove_if(_Pr1 _Pred)
		{	
		iterator _Last = end();
		for (iterator _First = begin(); _First != _Last; )
			if (_Pred(*_First))
				erase(_First++);
			else
				++_First; }

	void unique()
		{	
		iterator _First = begin(), _Last = end();
		if (_First != _Last)
			for (iterator _Next = _First; ++_Next != _Last; _Next = _First)
				if (*_First == *_Next)
					erase(_Next);
				else
					_First = _Next; }

	template<class _Pr2>
		void unique(_Pr2 _Pred)
		{	
		iterator _First = begin(), _Last = end();
		if (_First != _Last)
			for (iterator _Next = _First; ++_Next != _Last; _Next = _First)
				if (_Pred(*_First, *_Next))
					erase(_Next);
				else
					_First = _Next; }

	void merge(_Myt& _Right)
		{	
		if (&_Right != this)
			{	
			iterator _First1 = begin(), _Last1 = end();
			iterator _First2 = _Right.begin(), _Last2 = _Right.end();

			while (_First1 != _Last1 && _First2 != _Last2)
				if (*_First2 < *_First1)
					{	
					iterator _Mid2 = _First2;
					_Splice(_First1, _Right, _First2, ++_Mid2, 1);
					_First2 = _Mid2; }
				else
					++_First1;

			if (_First2 != _Last2)
				_Splice(_Last1, _Right, _First2, _Last2,
					_Right._Mysize); }}	

	template<class _Pr3>
		void merge(_Myt& _Right, _Pr3 _Pred)
		{	
		if (&_Right != this)
			{	
			iterator _First1 = begin(), _Last1 = end();
			iterator _First2 = _Right.begin(), _Last2 = _Right.end();

			while (_First1 != _Last1 && _First2 != _Last2)
				if (_Pred(*_First2, *_First1))
					{	
					iterator _Mid2 = _First2;
					_Splice(_First1, _Right, _First2, ++_Mid2, 1);
					_First2 = _Mid2; }
				else
					++_First1;

			if (_First2 != _Last2)
				_Splice(_Last1, _Right, _First2, _Last2,
					_Right._Mysize); }}	

	void sort()
		{	
		if (2 <= size())
			{	
			const size_t _MAXBINS = 25;
			_Myt _Templist(_Mybase::_Alval), _Binlist[_MAXBINS + 1];
			size_t _Maxbin = 0;

			while (!empty())
				{	
				_Templist.splice(_Templist.begin(), *this, begin());
				size_t _Bin;

				for (_Bin = 0; _Bin < _Maxbin && !_Binlist[_Bin].empty();
					++_Bin)
					{	
					_Binlist[_Bin].merge(_Templist);
					_Binlist[_Bin].swap(_Templist); }

				if (_Bin == _MAXBINS)
					_Binlist[_Bin - 1].merge(_Templist);
				else
					{	
					_Binlist[_Bin].swap(_Templist);
					if (_Bin == _Maxbin)
						++_Maxbin; }}

			for (size_t _Bin = 1; _Bin < _Maxbin; ++_Bin)
				_Binlist[_Bin].merge(_Binlist[_Bin - 1]);	
			swap(_Binlist[_Maxbin - 1]); }}	

	template<class _Pr3>
		void sort(_Pr3 _Pred)
		{	
		if (2 <= size())
			{	
			const size_t _MAXBINS = 25;
			_Myt _Templist(_Mybase::_Alval), _Binlist[_MAXBINS + 1];
			size_t _Maxbin = 0;

			while (!empty())
				{	
				_Templist.splice(_Templist.begin(), *this, begin());
				size_t _Bin;

				for (_Bin = 0; _Bin < _Maxbin && !_Binlist[_Bin].empty();
					++_Bin)
					{	
					_Binlist[_Bin].merge(_Templist, _Pred);
					_Binlist[_Bin].swap(_Templist); }

				if (_Bin == _MAXBINS)
					_Binlist[_Bin - 1].merge(_Templist, _Pred);
				else
					{	
					_Binlist[_Bin].swap(_Templist);
					if (_Bin == _Maxbin)
						++_Maxbin; }}

			for (size_t _Bin = 1; _Bin < _Maxbin; ++_Bin)
				_Binlist[_Bin].merge(_Binlist[_Bin - 1],
					_Pred);	
			swap(_Binlist[_Maxbin - 1]); }}	

	void reverse()
		{	
		if (2 <= size())
			{	
			iterator _Last = end();
			for (iterator _Next = ++begin(); _Next != _Last; )
				{	
				iterator _Before = _Next;
				_Splice(begin(), *this, _Before, ++_Next, 1); }}}

protected:
	_Nodeptr _Buynode(_Nodeptr _Narg = 0, _Nodeptr _Parg = 0)
		{	
		_Nodeptr _Pnode = _Alnod.allocate(1, (void *)0);
		_Alptr.construct(&_Next(_Pnode), _Narg != 0 ? _Narg : _Pnode);
		_Alptr.construct(&_Prev(_Pnode), _Parg != 0 ? _Parg : _Pnode);
		return (_Pnode); }

	void _Freenode(_Nodeptr _Pnode)
		{	
		_Alptr.destroy(&_Next(_Pnode));
		_Alptr.destroy(&_Prev(_Pnode));
		_Alnod.deallocate(_Pnode, 1); }

	void _Splice(iterator _Where, _Myt& _Right,
		iterator _First, iterator _Last, size_type _Count)
		{	
		if (_Mybase::_Alval == _Right._Alval)
			{	
			if (this != &_Right)
				{	
				_Incsize(_Count);
				_Right._Mysize -= _Count; }
			_Next(_Prev(_First._Mynode())) = _Last._Mynode();
			_Next(_Prev(_Last._Mynode())) = _Where._Mynode();
			_Next(_Prev(_Where._Mynode())) = _First._Mynode();
			_Nodeptr _Pnode = _Prev(_Where._Mynode());
			_Prev(_Where._Mynode()) = _Prev(_Last._Mynode());
			_Prev(_Last._Mynode()) = _Prev(_First._Mynode());
			_Prev(_First._Mynode()) = _Pnode; }
		else
			{	
			insert(_Where, _First, _Last);
			_Right.erase(_First, _Last); }}

	void _Incsize(size_type _Count)
		{	
		if (max_size() - size() < _Count)
			throw length_error("list<T> too long");
		_Mysize += _Count; }

	_Nodeptr _Head;	
	size_type _Mysize;	
	};

		
template<class _Ty, class _Alloc> inline
	void swap(list<_Ty, _Alloc>& _Left, list<_Ty, _Alloc>& _Right)
	{	
	_Left.swap(_Right); }

template<class _Ty, class _Alloc> inline
	bool operator==(const list<_Ty, _Alloc>& _Left,
		const list<_Ty, _Alloc>& _Right)
	{	
	return (_Left.size() == _Right.size()
		&& equal(_Left.begin(), _Left.end(), _Right.begin())); }

template<class _Ty, class _Alloc> inline
	bool operator!=(const list<_Ty, _Alloc>& _Left,
		const list<_Ty, _Alloc>& _Right)
	{	
	return (!(_Left == _Right)); }

template<class _Ty, class _Alloc> inline
	bool operator<(const list<_Ty, _Alloc>& _Left,
		const list<_Ty, _Alloc>& _Right)
	{	
	return (lexicographical_compare(_Left.begin(), _Left.end(),
		_Right.begin(), _Right.end())); }

template<class _Ty, class _Alloc> inline
	bool operator>(const list<_Ty, _Alloc>& _Left,
		const list<_Ty, _Alloc>& _Right)
	{	
	return (_Right < _Left); }

template<class _Ty, class _Alloc> inline
	bool operator<=(const list<_Ty, _Alloc>& _Left,
		const list<_Ty, _Alloc>& _Right)
	{	
	return (!(_Right < _Left)); }

template<class _Ty, class _Alloc> inline
	bool operator>=(const list<_Ty, _Alloc>& _Left,
		const list<_Ty, _Alloc>& _Right)
	{	
	return (!(_Left < _Right)); }

}	





 
















 
#line 32 "../../include/QtCore/../../src/corelib/tools/qlist.h"


#line 1 "/usr/include/CC/new"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/new /main/1"

 


 

#line 35 "../../include/QtCore/../../src/corelib/tools/qlist.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

template <typename T> class QVector;
template <typename T> class QSet;

struct  QListData {
    struct Data {
        QBasicAtomic ref;
        int alloc, begin, end;
        uint sharable : 1;
        void *array[1];
    };
    enum { DataHeaderSize = sizeof(Data) - sizeof(void *) };

    Data *detach();
    void realloc(int alloc);
    static Data shared_null;
    Data *d;
    void **erase(void **xi);
    void **append();
    void **append(const QListData &l);
    void **prepend();
    void **insert(int i);
    void remove(int i);
    void remove(int i, int n);
    void move(int from, int to);
    inline int size() const { return d->end - d->begin; }
    inline bool isEmpty() const { return d->end  == d->begin; }
    inline void **at(int i) const { return d->array + d->begin + i; }
    inline void **begin() const { return d->array + d->begin; }
    inline void **end() const { return d->array + d->end; }
};

template <typename T>
class QList
{
    struct Node { void *v;



        inline T &t()
        { return *reinterpret_cast<T*>(QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic
                                       ? v : this); }

    };

    union { QListData p; QListData::Data *d; };

public:
    inline QList() : d(&QListData::shared_null) { d->ref.ref(); }
    inline QList(const QList<T> &l) : d(l.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
    ~QList();
    QList<T> &operator=(const QList<T> &l);
    bool operator==(const QList<T> &l) const;
    inline bool operator!=(const QList<T> &l) const { return !(*this == l); }

    inline int size() const { return p.size(); }

    inline void detach() { if (d->ref != 1) detach_helper(); }
    inline bool isDetached() const { return d->ref == 1; }
    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }

    inline bool isEmpty() const { return p.isEmpty(); }

    void clear();

    const T &at(int i) const;
    const T &operator[](int i) const;
    T &operator[](int i);

    void append(const T &t);
    void prepend(const T &t);
    void insert(int i, const T &t);
    void replace(int i, const T &t);
    void removeAt(int i);
    int removeAll(const T &t);
    T takeAt(int i);
    T takeFirst();
    T takeLast();
    void move(int from, int to);
    void swap(int i, int j);
    int indexOf(const T &t, int from = 0) const;
    int lastIndexOf(const T &t, int from = -1) const;
    QBool contains(const T &t) const;
    int count(const T &t) const;

    class const_iterator;

    class iterator {
    public:
        Node *i;
        typedef std::random_access_iterator_tag  iterator_category;
        typedef ptrdiff_t  difference_type;
        typedef T value_type;
        typedef T *pointer;
        typedef T &reference;

        inline iterator() : i(0) {}
        inline iterator(Node *n) : i(n) {}
        inline iterator(const iterator &o): i(o.i){}
        inline T &operator*() const { return i->t(); }
        inline T *operator->() const { return &i->t(); }
        inline T &operator[](int j) const { return i[j].t(); }
        inline bool operator==(const iterator &o) const { return i == o.i; }
        inline bool operator!=(const iterator &o) const { return i != o.i; }
        inline bool operator<(const iterator& other) const { return i < other.i; }
        inline bool operator<=(const iterator& other) const { return i <= other.i; }
        inline bool operator>(const iterator& other) const { return i > other.i; }
        inline bool operator>=(const iterator& other) const { return i >= other.i; }
        inline bool operator==(const const_iterator &o) const
            { return i == reinterpret_cast<const iterator &>(o).i; }
        inline bool operator!=(const const_iterator &o) const
            { return i != reinterpret_cast<const iterator &>(o).i; }
        inline bool operator<(const const_iterator& other) const
            { return i < reinterpret_cast<const iterator &>(other).i; }
        inline bool operator<=(const const_iterator& other) const
            { return i <= reinterpret_cast<const iterator &>(other).i; }
        inline bool operator>(const const_iterator& other) const
            { return i > reinterpret_cast<const iterator &>(other).i; }
        inline bool operator>=(const const_iterator& other) const
            { return i >= reinterpret_cast<const iterator &>(other).i; }
        inline iterator &operator++() { ++i; return *this; }
        inline iterator operator++(int) { Node *n = i; ++i; return n; }
        inline iterator &operator--() { i--; return *this; }
        inline iterator operator--(int) { Node *n = i; i--; return n; }
        inline iterator &operator+=(int j) { i+=j; return *this; }
        inline iterator &operator-=(int j) { i-=j; return *this; }
        inline iterator operator+(int j) const { return iterator(i+j); }
        inline iterator operator-(int j) const { return iterator(i-j); }
        inline int operator-(iterator j) const { return i - j.i; }
    };
    friend class iterator;

    class const_iterator {
    public:
        Node *i;
        typedef std::random_access_iterator_tag  iterator_category;
        typedef ptrdiff_t difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        inline const_iterator() : i(0) {}
        inline const_iterator(Node *n) : i(n) {}
        inline const_iterator(const const_iterator &o): i(o.i) {}
        inline const_iterator(const iterator &o): i(o.i) {}
        inline const T &operator*() const { return i->t(); }
        inline const T *operator->() const { return &i->t(); }
        inline const T &operator[](int j) const { return i[j].t(); }
        inline bool operator==(const const_iterator &o) const { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
        inline bool operator<(const const_iterator& other) const { return i < other.i; }
        inline bool operator<=(const const_iterator& other) const { return i <= other.i; }
        inline bool operator>(const const_iterator& other) const { return i > other.i; }
        inline bool operator>=(const const_iterator& other) const { return i >= other.i; }
        inline const_iterator &operator++() { ++i; return *this; }
        inline const_iterator operator++(int) { Node *n = i; ++i; return n; }
        inline const_iterator &operator--() { i--; return *this; }
        inline const_iterator operator--(int) { Node *n = i; i--; return n; }
        inline const_iterator &operator+=(int j) { i+=j; return *this; }
        inline const_iterator &operator-=(int j) { i+=j; return *this; }
        inline const_iterator operator+(int j) const { return const_iterator(i+j); }
        inline const_iterator operator-(int j) const { return const_iterator(i-j); }
        inline int operator-(const_iterator j) const { return i - j.i; }
    };
    friend class const_iterator;

    
    inline iterator begin() { detach(); return reinterpret_cast<Node *>(p.begin()); }
    inline const_iterator begin() const { return reinterpret_cast<Node *>(p.begin()); }
    inline const_iterator constBegin() const { return reinterpret_cast<Node *>(p.begin()); }
    inline iterator end() { detach(); return reinterpret_cast<Node *>(p.end()); }
    inline const_iterator end() const { return reinterpret_cast<Node *>(p.end()); }
    inline const_iterator constEnd() const { return reinterpret_cast<Node *>(p.end()); }
    iterator insert(iterator before, const T &t);
    iterator erase(iterator pos);
    iterator erase(iterator first, iterator last);

    
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    inline int count() const { return p.size(); }
    inline T& first() { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qlist.h",220);} while (0); return *begin(); }
    inline const T& first() const { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qlist.h",221);} while (0); return *begin(); }
    T& last() { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qlist.h",222);} while (0); return *(--end()); }
    const T& last() const { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qlist.h",223);} while (0); return *(--end()); }
    inline void removeFirst() { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qlist.h",224);} while (0); erase(begin()); }
    inline void removeLast() { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qlist.h",225);} while (0); erase(--end()); }
    QList<T> mid(int pos, int length = -1) const;

    T value(int i) const;
    T value(int i, const T &defaultValue) const;

    
    inline void push_back(const T &t) { append(t); }
    inline void push_front(const T &t) { prepend(t); }
    inline T& front() { return first(); }
    inline const T& front() const { return first(); }
    inline T& back() { return last(); }
    inline const T& back() const { return last(); }
    inline void pop_front() { removeFirst(); }
    inline void pop_back() { removeLast(); }
    inline bool empty() const { return isEmpty(); }
    typedef int size_type;
    typedef T value_type;
    typedef value_type *pointer;
    typedef const value_type *const_pointer;
    typedef value_type &reference;
    typedef const value_type &const_reference;


    inline  iterator remove(iterator pos) { return erase(pos); }
    inline  int remove(const T &t) { return removeAll(t); }
    inline  int findIndex(const T& t) const { return indexOf(t); }
    inline  iterator find(const T& t)
    { int i = indexOf(t); return (i == -1 ? end() : (begin()+i)); }
    inline  const_iterator find (const T& t) const
    { int i = indexOf(t); return (i == -1 ? end() : (begin()+i)); }
    inline  iterator find(iterator from, const T& t)
    { int i = indexOf(t, from - begin()); return i == -1 ? end() : begin()+i; }
    inline  const_iterator find(const_iterator from, const T& t) const
    { int i = indexOf(t, from - begin()); return i == -1 ? end() : begin()+i; }


    
    QList<T> &operator+=(const QList<T> &l);
    inline QList<T> operator+(const QList<T> &l) const
    { QList n = *this; n += l; return n; }
    inline QList<T> &operator+=(const T &t)
    { append(t); return *this; }
    inline QList<T> &operator<< (const T &t)
    { append(t); return *this; }
    inline QList<T> &operator<<(const QList<T> &l)
    { *this += l; return *this; }

    QVector<T> toVector() const;
    QSet<T> toSet() const;

    static QList<T> fromVector(const QVector<T> &vector);
    static QList<T> fromSet(const QSet<T> &set);


    static inline QList<T> fromStdList(const std::list<T> &list)
    { QList<T> tmp; qCopy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; }
    inline std::list<T> toStdList() const
    { std::list<T> tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }


private:
    void detach_helper();
    void free(QListData::Data *d);

    void node_construct(Node *n, const T &t);
    void node_destruct(Node *n);
    void node_copy(Node *from, Node *to, Node *src);
    void node_destruct(Node *from, Node *to);
};







template <typename T>
inline void QList<T>::node_construct(Node *n, const T &t)
{
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) n->v = new T(t);
    else if (QTypeInfo<T>::isComplex) new (n) T(t);
    else *reinterpret_cast<T*>(n) = t;
}

template <typename T>
inline void QList<T>::node_destruct(Node *n)
{
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) delete reinterpret_cast<T*>(n->v);
    else if (QTypeInfo<T>::isComplex) reinterpret_cast<T*>(n)->~T();
}

template <typename T>
inline void QList<T>::node_copy(Node *from, Node *to, Node *src)
{
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic)
        while(from != to)
            (from++)->v = new T(*reinterpret_cast<T*>((src++)->v));
    else if (QTypeInfo<T>::isComplex)
        while(from != to)
            new (from++) T(*reinterpret_cast<T*>(src++));
}

template <typename T>
inline void QList<T>::node_destruct(Node *from, Node *to)
{
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic)
        while(from != to) --to, delete reinterpret_cast<T*>(to->v);
    else if (QTypeInfo<T>::isComplex)
        while (from != to) --to, reinterpret_cast<T*>(to)->~T();
}

template <typename T>
inline QList<T> &QList<T>::operator=(const QList<T> &l)
{
    if (d != l.d) {
        QListData::Data *x = l.d;
        x->ref.ref();
        x = qAtomicSetPtr(&d, x);
        if (!x->ref.deref())
            free(x);
        if (!d->sharable)
            detach_helper();
    }
    return *this;
}
template <typename T>
inline typename QList<T>::iterator QList<T>::insert(iterator before, const T &t)
{ Node *n = reinterpret_cast<Node *>(p.insert(before.i-reinterpret_cast<Node *>(p.begin())));
 node_construct(n,t); return n; }
template <typename T>
inline typename QList<T>::iterator QList<T>::erase(iterator it)
{ node_destruct(it.i);
 return reinterpret_cast<Node *>(p.erase(reinterpret_cast<void**>(it.i))); }
template <typename T>
inline const T &QList<T>::at(int i) const
{ do {if(!(i >= 0 && i < p . size()))qt_assert_x("QList<T>::at", "index out of range","../../include/QtCore/../../src/corelib/tools/qlist.h",361);} while (0);
 return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline const T &QList<T>::operator[](int i) const
{ do {if(!(i >= 0 && i < p . size()))qt_assert_x("QList<T>::operator[]", "index out of range","../../include/QtCore/../../src/corelib/tools/qlist.h",365);} while (0);
 return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline T &QList<T>::operator[](int i)
{ do {if(!(i >= 0 && i < p . size()))qt_assert_x("QList<T>::operator[]", "index out of range","../../include/QtCore/../../src/corelib/tools/qlist.h",369);} while (0);
  detach(); return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline void QList<T>::removeAt(int i)
{ if(i >= 0 && i < p.size()) { detach();
 node_destruct(reinterpret_cast<Node *>(p.at(i))); p.remove(i); } }
template <typename T>
inline T QList<T>::takeAt(int i)
{ do {if(!(i >= 0 && i < p . size()))qt_assert_x("QList<T>::take", "index out of range","../../include/QtCore/../../src/corelib/tools/qlist.h",377);} while (0);
 detach(); Node *n = reinterpret_cast<Node *>(p.at(i)); T t = n->t(); node_destruct(n);
 p.remove(i); return t; }
template <typename T>
inline T QList<T>::takeFirst()
{ T t = first(); removeFirst(); return t; }
template <typename T>
inline T QList<T>::takeLast()
{ T t = last(); removeLast(); return t; }

template <typename T>
 void QList<T>::append(const T &t)
{
    detach();
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        node_construct(reinterpret_cast<Node *>(p.append()), t);
    } else {
        const T cpy(t);
        node_construct(reinterpret_cast<Node *>(p.append()), cpy);
    }
}

template <typename T>
inline void QList<T>::prepend(const T &t)
{
    detach();
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        node_construct(reinterpret_cast<Node *>(p.prepend()), t);
    } else {
        const T cpy(t);
        node_construct(reinterpret_cast<Node *>(p.prepend()), cpy);
    }
}

template <typename T>
inline void QList<T>::insert(int i, const T &t)
{
    detach();
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        node_construct(reinterpret_cast<Node *>(p.insert(i)), t);
    } else {
        const T cpy(t);
        node_construct(reinterpret_cast<Node *>(p.insert(i)), cpy);
    }
}

template <typename T>
inline void QList<T>::replace(int i, const T &t)
{
    do {if(!(i >= 0 && i < p . size()))qt_assert_x("QList<T>::replace", "index out of range","../../include/QtCore/../../src/corelib/tools/qlist.h",426);} while (0);
    detach();
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        reinterpret_cast<Node *>(p.at(i))->t() = t;
    } else {
        const T cpy(t);
        reinterpret_cast<Node *>(p.at(i))->t() = cpy;
    }
}

template <typename T>
inline void QList<T>::swap(int i, int j)
{
    do {if(!(i >= 0 && i < p . size() && j >= 0 && j < p . size()))qt_assert_x("QList<T>::swap", "index out of range","../../include/QtCore/../../src/corelib/tools/qlist.h",439);} while (0);

    detach();
    void *t = d->array[d->begin + i];
    d->array[d->begin + i] = d->array[d->begin + j];
    d->array[d->begin + j] = t;
}

template <typename T>
inline void QList<T>::move(int from, int to)
{
    do {if(!(from >= 0 && from < p . size() && to >= 0 && to < p . size()))qt_assert_x("QList<T>::move", "index out of range","../../include/QtCore/../../src/corelib/tools/qlist.h",450);} while (0);

    detach();
    p.move(from, to);
}

template<typename T>
 QList<T> QList<T>::mid(int pos, int length) const
{
    if (length < 0)
        length = size() - pos;
    if (pos == 0 && length == size())
        return *this;
    QList<T> cpy;
    if (pos + length > size())
        length = size() - pos;
    for (int i = pos; i < pos + length; ++i)
        cpy += at(i);
    return cpy;
}

template<typename T>
 T QList<T>::value(int i) const
{
    if (i < 0 || i >= p.size()) {
        return T();
    }
    return reinterpret_cast<Node *>(p.at(i))->t();
}
template<typename T>
 T QList<T>::value(int i, const T& defaultValue) const
{
    return ((i < 0 || i >= p.size()) ? defaultValue : reinterpret_cast<Node *>(p.at(i))->t());
}

template <typename T>
 void QList<T>::detach_helper()
{
    Node *n = reinterpret_cast<Node *>(p.begin());
    QListData::Data *x = p.detach();
    if (x)
        free(x);
    node_copy(reinterpret_cast<Node *>(p.begin()), reinterpret_cast<Node *>(p.end()), n);
}

template <typename T>
 QList<T>::~QList()
{
    if (!d)
        return;
    QListData::Data *x = &QListData::shared_null;
    x = qAtomicSetPtr(&d, x);
    if (!x->ref.deref())
        free(x);
}

template <typename T>
 bool QList<T>::operator==(const QList<T> &l) const
{
    if (p.size() != l.p.size())
        return false;
    if (d == l.d)
        return true;
    Node *i = reinterpret_cast<Node *>(p.end());
    Node *b = reinterpret_cast<Node *>(p.begin());
    Node *li = reinterpret_cast<Node *>(l.p.end());
    while (i != b) {
        --i; --li;
        if (!(i->t() == li->t()))
            return false;
    }
    return true;
}


template <typename T>
 void QList<T>::free(QListData::Data *data)
{
    node_destruct(reinterpret_cast<Node *>(data->array + data->begin),
                  reinterpret_cast<Node *>(data->array + data->end));
    if (data->ref == 0)
        qFree(data);
}


template <typename T>
 void QList<T>::clear()
{
    *this = QList<T>();
}

template <typename T>
 int QList<T>::removeAll(const T &_t)
{
    detach();
    const T t = _t;
    int removedCount=0, i=0;
    Node *n;
    while (i < p.size())
        if ((n = reinterpret_cast<Node *>(p.at(i)))->t() == t) {
            node_destruct(n);
            p.remove(i);
            ++removedCount;
        } else {
            ++i;
        }
    return removedCount;
}

template <typename T>
 typename QList<T>::iterator QList<T>::erase(typename QList<T>::iterator afirst,
                                                                 typename QList<T>::iterator alast)
{
    for (Node *n = afirst.i; n < alast.i; ++n)
        node_destruct(n);
    int idx = afirst - begin();
    p.remove(idx, alast - afirst);
    return begin() + idx;
}

template <typename T>
 QList<T> &QList<T>::operator+=(const QList<T> &l)
{
    detach();
    Node *n = reinterpret_cast<Node *>(p.append(l.p));
    node_copy(n, reinterpret_cast<Node *>(p.end()), reinterpret_cast<Node *>(l.p.begin()));
    return *this;
}

template <typename T>
 int QList<T>::indexOf(const T &t, int from) const
{
    if (from < 0)
        from = qMax(from + p.size(), 0);
    if (from < p.size()) {
        Node *n = reinterpret_cast<Node *>(p.at(from -1));
        Node *e = reinterpret_cast<Node *>(p.end());
        while (++n != e)
            if (n->t() == t)
                return n - reinterpret_cast<Node *>(p.begin());
    }
    return -1;
}

template <typename T>
 int QList<T>::lastIndexOf(const T &t, int from) const
{
    if (from < 0)
        from += p.size();
    else if (from >= p.size())
        from = p.size()-1;
    if (from >= 0) {
        Node *b = reinterpret_cast<Node *>(p.begin());
        Node *n = reinterpret_cast<Node *>(p.at(from + 1));
        while (n-- != b) {
            if (n->t() == t)
                return n - b;
        }
    }
    return -1;
}

template <typename T>
 QBool QList<T>::contains(const T &t) const
{
    Node *b = reinterpret_cast<Node *>(p.begin());
    Node *i = reinterpret_cast<Node *>(p.end());
    while (i-- != b)
        if (i->t() == t)
            return QBool(true);
    return QBool(false);
}

template <typename T>
 int QList<T>::count(const T &t) const
{
    int c = 0;
    Node *b = reinterpret_cast<Node *>(p.begin());
    Node *i = reinterpret_cast<Node *>(p.end());
    while (i-- != b)
        if (i->t() == t)
            ++c;
    return c;
}

template <class T> class QListIterator { typedef typename QList<T> ::const_iterator const_iterator; QList<T> c; const_iterator i; public: inline QListIterator(const QList<T> &container) : c(container), i(c . constBegin()) {} inline QListIterator &operator=(const QList<T> &container) { c = container; i = c . constBegin(); return *this; } inline void toFront() { i = c . constBegin(); } inline void toBack() { i = c . constEnd(); } inline bool hasNext() const { return i != c . constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c . constBegin(); } inline const T &previous() { return * --i; } inline const T &peekPrevious() const { const_iterator p = i; return * --p; } inline bool findNext(const T &t) { while (i != c . constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c . constBegin()) if (*(--i) == t) return true; return false; } };
template <class T> class QMutableListIterator { typedef typename QList<T> ::iterator iterator; QList<T> *c; iterator i, n; inline bool item_exists() const { return n != c->constEnd(); } public: inline QMutableListIterator(QList<T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableListIterator() { c->setSharable(true); } inline QMutableListIterator &operator=(QList<T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != i; } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != i; } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return * --p; } inline void remove() { if (c->constEnd() != n) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != n) *n = t; } inline T &value() { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qlist.h",636);} while (0); return *n; } inline const T &value() const { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qlist.h",636);} while (0); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != (n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != i) if (*(n = --i) == t) return true; n = c->end(); return false; } };



#line 2 "../../include/QtCore/qlist.h"
#line 29 "../../include/QtCore/../../src/corelib/tools/qhash.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class QByteArray;
class QString;

inline uint qHash(char key) { return uint(key); }
inline uint qHash(uchar key) { return uint(key); }
inline uint qHash(signed char key) { return uint(key); }
inline uint qHash(ushort key) { return uint(key); }
inline uint qHash(short key) { return uint(key); }
inline uint qHash(uint key) { return key; }
inline uint qHash(int key) { return uint(key); }
inline uint qHash(ulong key)
{
    if (sizeof(ulong) > sizeof(uint)) {
        return uint((key >> (8 * sizeof(uint) - 1)) ^ key);
    } else {
        return uint(key);
    }
}
inline uint qHash(long key) { return qHash(ulong(key)); }
inline uint qHash(quint64 key)
{
    if (sizeof(quint64) > sizeof(uint)) {
        return uint((key >> (8 * sizeof(uint) - 1)) ^ key);
    } else {
        return uint(key);
    }
}
inline uint qHash(qint64 key) { return qHash(quint64(key)); }
inline uint qHash(QChar key) { return qHash(key.unicode()); }
 uint qHash(const QByteArray &key);
 uint qHash(const QString &key);





template <class T> inline uint qHash(const T *key)
{
    if (sizeof(const T *) > sizeof(uint))
        return qHash(reinterpret_cast<quint64>(key));
    else
        return uint(reinterpret_cast<ulong>(key));
}




struct  QHashData
{
    struct Node {
        Node *next;
        uint h;
    };

    Node *fakeNext;
    Node **buckets;
    QBasicAtomic ref;
    int size;
    int nodeSize;
    short userNumBits;
    short numBits;
    int numBuckets;
    uint sharable : 1;

    void *allocateNode();
    void freeNode(void *node);
    QHashData *detach_helper(void (*node_duplicate)(Node *, void *), int nodeSize);
    void mightGrow();
    void hasShrunk();
    void rehash(int hint);
    void destroyAndFree();
    Node *firstNode();
    static Node *nextNode(Node *node);
    static Node *previousNode(Node *node);

    static QHashData shared_null;
};

inline void QHashData::mightGrow()
{
    if (size >= numBuckets)
        rehash(numBits + 1);
}

inline void QHashData::hasShrunk()
{
    if (size <= (numBuckets >> 3) && numBits > userNumBits)
        rehash(qMax(int(numBits) - 2, int(userNumBits)));
}

inline QHashData::Node *QHashData::firstNode()
{
    Node *e = reinterpret_cast<Node *>(this);
    Node **bucket = buckets;
    int n = numBuckets;
    while (n--) {
        if (*bucket != e)
            return *bucket;
        ++bucket;
    }
    return e;
}

struct QHashDummyValue
{
};

inline bool operator==(const QHashDummyValue &  , const QHashDummyValue &  )
{
    return true;
}

template <> class QTypeInfo<QHashDummyValue> { public: enum { isComplex = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QHashDummyValue)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QHashDummyValue"; } };

template <class Key, class T>
struct QHashDummyNode
{
    QHashDummyNode *next;
    uint h;
    Key key;

    inline QHashDummyNode(const Key &key0) : key(key0) {}
};

template <class Key, class T>
struct QHashNode
{
    QHashNode *next;
    uint h;
    Key key;
    T value;

    inline QHashNode(const Key &key0) : key(key0) {} 
    inline QHashNode(const Key &key0, const T &value0) : key(key0), value(value0) {}
    inline bool same_key(uint h0, const Key &key0) { return h0 == h && key0 == key; }
};

#line 191 "../../include/QtCore/../../src/corelib/tools/qhash.h"


template <class T> struct QHashDummyNode<short, T> { QHashDummyNode *next; union { uint h; short key; }; inline QHashDummyNode(short ) {} }; template <class T> struct QHashNode<short, T> { QHashNode *next; union { uint h; short key; }; T value; inline QHashNode(short ) {} inline QHashNode(short , const T &value0) : value(value0) {} inline bool same_key(uint h0, short) { return h0 == h; } };
template <class T> struct QHashDummyNode<ushort, T> { QHashDummyNode *next; union { uint h; ushort key; }; inline QHashDummyNode(ushort ) {} }; template <class T> struct QHashNode<ushort, T> { QHashNode *next; union { uint h; ushort key; }; T value; inline QHashNode(ushort ) {} inline QHashNode(ushort , const T &value0) : value(value0) {} inline bool same_key(uint h0, ushort) { return h0 == h; } };

template <class T> struct QHashDummyNode<int, T> { QHashDummyNode *next; union { uint h; int key; }; inline QHashDummyNode(int ) {} }; template <class T> struct QHashNode<int, T> { QHashNode *next; union { uint h; int key; }; T value; inline QHashNode(int ) {} inline QHashNode(int , const T &value0) : value(value0) {} inline bool same_key(uint h0, int) { return h0 == h; } };
template <class T> struct QHashDummyNode<uint, T> { QHashDummyNode *next; union { uint h; uint key; }; inline QHashDummyNode(uint ) {} }; template <class T> struct QHashNode<uint, T> { QHashNode *next; union { uint h; uint key; }; T value; inline QHashNode(uint ) {} inline QHashNode(uint , const T &value0) : value(value0) {} inline bool same_key(uint h0, uint) { return h0 == h; } };



template <class Key, class T>
class QHash
{
    typedef QHashDummyNode<Key, T> DummyNode;
    typedef QHashNode<Key, T> Node;

    union {
        QHashData *d;
        QHashNode<Key, T> *e;
    };

    static inline Node *concrete(QHashData::Node *node) {
        return reinterpret_cast<Node *>(node);
    }

public:
    inline QHash() : d(&QHashData::shared_null) { d->ref.ref(); }
    inline QHash(const QHash<Key, T> &other) : d(other.d) { d->ref.ref(); if (!d->sharable) detach(); }
    inline ~QHash() { if (!d->ref.deref()) freeData(d); }

    QHash<Key, T> &operator=(const QHash<Key, T> &other);

    bool operator==(const QHash<Key, T> &other) const;
    inline bool operator!=(const QHash<Key, T> &other) const { return !(*this == other); }

    inline int size() const { return d->size; }

    inline bool isEmpty() const { return d->size == 0; }

    inline int capacity() const { return d->numBuckets; }
    void reserve(int size);
    inline void squeeze() { reserve(1); }

    inline void detach() { if (d->ref != 1) detach_helper(); }
    inline bool isDetached() const { return d->ref == 1; }
    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }

    void clear();

    int remove(const Key &key);
    T take(const Key &key);

    bool contains(const Key &key) const;
    const Key key(const T &value) const;
    const T value(const Key &key) const;
    const T value(const Key &key, const T &defaultValue) const;
    T &operator[](const Key &key);
    const T operator[](const Key &key) const;

    QList<Key> keys() const;
    QList<Key> keys(const T &value) const;
    QList<T> values() const;
    QList<T> values(const Key &key) const;
    int count(const Key &key) const;

    class const_iterator;

    class iterator
    {
        QHashData::Node *i;
    public:
        typedef std::bidirectional_iterator_tag iterator_category;
        typedef ptrdiff_t difference_type;
        typedef T value_type;
        typedef T *pointer;
        typedef T &reference;

        inline operator Node *() const { return concrete(i); }
        inline iterator() : i(0) { }
        explicit inline iterator(void *node) : i(reinterpret_cast<QHashData::Node *>(node)) { }

        inline const Key &key() const { return concrete(i)->key; }
        inline T &value() const { return concrete(i)->value; }
        inline T &operator*() const { return concrete(i)->value; }
        inline T *operator->() const { return &concrete(i)->value; }
        inline bool operator==(const iterator &o) const { return i == o.i; }
        inline bool operator!=(const iterator &o) const { return i != o.i; }
        inline bool operator==(const const_iterator &o) const
            { return i == reinterpret_cast<const iterator &>(o).i; }
        inline bool operator!=(const const_iterator &o) const
            { return i != reinterpret_cast<const iterator &>(o).i; }

        inline iterator &operator++() {
            i = QHashData::nextNode(i);
            return *this;
        }
        inline iterator operator++(int) {
            iterator r = *this;
            i = QHashData::nextNode(i);
            return r;
        }
        inline iterator &operator--() {
            i = QHashData::previousNode(i);
            return *this;
        }
        inline iterator operator--(int) {
            iterator r = *this;
            i = QHashData::previousNode(i);
            return r;
        }
        inline iterator operator+(int j) const
        { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
        inline iterator operator-(int j) const { return operator+(-j); }
        inline iterator &operator+=(int j) { return *this = *this + j; }
        inline iterator &operator-=(int j) { return *this = *this - j; }
    };
    friend class iterator;

    class const_iterator
    {
        QHashData::Node *i;
    public:
        typedef std::bidirectional_iterator_tag iterator_category;
        typedef ptrdiff_t difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        inline operator Node *() const { return concrete(i); }
        inline const_iterator() : i(0) { }
        explicit inline const_iterator(void *node)
            : i(reinterpret_cast<QHashData::Node *>(node)) { }
        inline const_iterator(const iterator &o)
        { i = reinterpret_cast<const const_iterator &>(o).i; }

        inline const Key &key() const { return concrete(i)->key; }
        inline const T &value() const { return concrete(i)->value; }
        inline const T &operator*() const { return concrete(i)->value; }
        inline const T *operator->() const { return &concrete(i)->value; }
        inline bool operator==(const const_iterator &o) const { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const { return i != o.i; }

        inline const_iterator &operator++() {
            i = QHashData::nextNode(i);
            return *this;
        }
        inline const_iterator operator++(int) {
            const_iterator r = *this;
            i = QHashData::nextNode(i);
            return r;
        }
        inline const_iterator &operator--() {
            i = QHashData::previousNode(i);
            return *this;
        }
        inline const_iterator operator--(int) {
            const_iterator r = *this;
            i = QHashData::previousNode(i);
            return r;
        }
        inline const_iterator operator+(int j) const
        { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
        inline const_iterator operator-(int j) const { return operator+(-j); }
        inline const_iterator &operator+=(int j) { return *this = *this + j; }
        inline const_iterator &operator-=(int j) { return *this = *this - j; }
    };
    friend class const_iterator;

    
    inline iterator begin() { detach(); return iterator(d->firstNode()); }
    inline const_iterator begin() const { return const_iterator(d->firstNode()); }
    inline const_iterator constBegin() const { return const_iterator(d->firstNode()); }
    inline iterator end() { detach(); return iterator(e); }
    inline const_iterator end() const { return const_iterator(e); }
    inline const_iterator constEnd() const { return const_iterator(e); }
    iterator erase(iterator it);

    
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    inline int count() const { return d->size; }
    iterator find(const Key &key);
    const_iterator find(const Key &key) const;
    const_iterator constFind(const Key &key) const;
    iterator insert(const Key &key, const T &value);
    iterator insertMulti(const Key &key, const T &value);
    QHash<Key, T> &unite(const QHash<Key, T> &other);

    
    inline bool empty() const { return isEmpty(); }

private:
    void detach_helper();
    void freeData(QHashData *d);
    Node **findNode(const Key &key, uint *hp = 0) const;
    Node *createNode(uint h, const Key &key, const T &value, Node **nextNode);
    void deleteNode(Node *node);

    static void duplicateNode(QHashData::Node *originalNode, void *newNode);
};

template <class Key, class T>
inline void QHash<Key, T>::deleteNode(Node *node)
{





    node->~Node();

    d->freeNode(node);
}

template <class Key, class T>
inline void QHash<Key, T>::duplicateNode(QHashData::Node *node, void *newNode)
{
    Node *concreteNode = concrete(node);
    if (QTypeInfo<T>::isDummy) {
        (void) new (newNode) DummyNode(concreteNode->key);
    } else {
        (void) new (newNode) Node(concreteNode->key, concreteNode->value);
    }
}

template <class Key, class T>
inline typename QHash<Key, T>::Node *
QHash<Key, T>::createNode(uint ah, const Key &akey, const T &avalue, Node **anextNode)
{
    Node *node;

    if (QTypeInfo<T>::isDummy) {
        node = reinterpret_cast<Node *>(new (d->allocateNode()) DummyNode(akey));
    } else {
        node = new (d->allocateNode()) Node(akey, avalue);
    }

    node->h = ah;
    node->next = *anextNode;
    *anextNode = node;
    ++d->size;
    return node;
}

template <class Key, class T>
inline QHash<Key, T> &QHash<Key, T>::unite(const QHash<Key, T> &other)
{
    QHash<Key, T> copy(other);
    const_iterator it = copy.constEnd();
    while (it != copy.constBegin()) {
        --it;
        insertMulti(it.key(), it.value());
    }
    return *this;
}

template <class Key, class T>
 void QHash<Key, T>::freeData(QHashData *x)
{
    Node *e_for_x = reinterpret_cast<Node *>(x);
    Node **bucket = reinterpret_cast<Node **>(x->buckets);
    int n = x->numBuckets;
    while (n--) {
        Node *cur = *bucket++;
        while (cur != e_for_x) {
            Node *next = cur->next;
            deleteNode(cur);
            cur = next;
        }
    }
    x->destroyAndFree();
}

template <class Key, class T>
inline void QHash<Key, T>::clear()
{
    *this = QHash<Key,T>();
}

template <class Key, class T>
 void QHash<Key, T>::detach_helper()
{
    size_t asize;
    if (QTypeInfo<T>::isDummy) {
        asize = reinterpret_cast<char *>(&reinterpret_cast<Node *>(&QHashData::shared_null)->value)
               - reinterpret_cast<char *>(&QHashData::shared_null);
    } else {
        asize = sizeof(Node);
    }

    QHashData *x = d->detach_helper(duplicateNode, int(asize));
    x = qAtomicSetPtr(&d, x);
    if (!x->ref.deref())
        freeData(x);
}

template <class Key, class T>
inline QHash<Key, T> &QHash<Key, T>::operator=(const QHash<Key, T> &other)
{
    if (d != other.d) {
        QHashData *x = other.d;
        x->ref.ref();
        x = qAtomicSetPtr(&d, x);
        if (!x->ref.deref())
            freeData(x);
        if (!d->sharable)
            detach_helper();
    }
    return *this;
}

template <class Key, class T>
inline const T QHash<Key, T>::value(const Key &akey) const
{
    Node *node = *findNode(akey);
    if (node == e) {
        return T();
    } else {
        return node->value;
    }
}

template <class Key, class T>
inline const T QHash<Key, T>::value(const Key &akey, const T &adefaultValue) const
{
    Node *node = *findNode(akey);
    if (node == e) {
        return adefaultValue;
    } else {
        return node->value;
    }
}

template <class Key, class T>
 QList<Key> QHash<Key, T>::keys() const
{
    QList<Key> res;
    const_iterator i = begin();
    while (i != end()) {
        res.append(i.key());
        ++i;
    }
    return res;
}

template <class Key, class T>
 QList<Key> QHash<Key, T>::keys(const T &avalue) const
{
    QList<Key> res;
    const_iterator i = begin();
    while (i != end()) {
        if (i.value() == avalue)
            res.append(i.key());
        ++i;
    }
    return res;
}

template <class Key, class T>
 const Key QHash<Key, T>::key(const T &avalue) const
{
    const_iterator i = begin();
    while (i != end()) {
        if (i.value() == avalue)
            return i.key();
        ++i;
    }

    return Key();
}

template <class Key, class T>
 QList<T> QHash<Key, T>::values() const
{
    QList<T> res;
    const_iterator i = begin();
    while (i != end()) {
        res.append(i.value());
        ++i;
    }
    return res;
}

template <class Key, class T>
 QList<T> QHash<Key, T>::values(const Key &akey) const
{
    QList<T> res;
    Node *node = *findNode(akey);
    if (node != e) {
        do {
            res.append(node->value);
        } while ((node = node->next) != e && node->key == akey);
    }
    return res;
}

template <class Key, class T>
 int QHash<Key, T>::count(const Key &akey) const
{
    int cnt = 0;
    Node *node = *findNode(akey);
    if (node != e) {
        do {
            ++cnt;
        } while ((node = node->next) != e && node->key == akey);
    }
    return cnt;
}

template <class Key, class T>
inline const T QHash<Key, T>::operator[](const Key &akey) const
{
    return value(akey);
}

template <class Key, class T>
inline T &QHash<Key, T>::operator[](const Key &akey)
{
    detach();
    d->mightGrow();

    uint h;
    Node **node = findNode(akey, &h);
    if (*node == e)
        return createNode(h, akey, T(), node)->value;
    return (*node)->value;
}

template <class Key, class T>
inline typename QHash<Key, T>::iterator QHash<Key, T>::insert(const Key &akey,
                                                                         const T &avalue)
{
    detach();
    d->mightGrow();

    uint h;
    Node **node = findNode(akey, &h);
    if (*node == e)
        return iterator(createNode(h, akey, avalue, node));

    if (!QTypeInfo<T>::isDummy)
        (*node)->value = avalue;
    return iterator(*node);
}

template <class Key, class T>
inline typename QHash<Key, T>::iterator QHash<Key, T>::insertMulti(const Key &akey,
                                                                              const T &avalue)
{
    detach();
    d->mightGrow();

    uint h;
    Node **nextNode = findNode(akey, &h);
    return iterator(createNode(h, akey, avalue, nextNode));
}

template <class Key, class T>
 int QHash<Key, T>::remove(const Key &akey)
{
    detach();

    int oldSize = d->size;
    Node **node = findNode(akey);
    if (*node != e) {
        bool deleteNext = true;
        do {
            Node *next = (*node)->next;
            deleteNext = (next != e && next->key == (*node)->key);
            deleteNode(*node);
            *node = next;
            --d->size;
        } while (deleteNext);
        d->hasShrunk();
    }
    return oldSize - d->size;
}

template <class Key, class T>
 T QHash<Key, T>::take(const Key &akey)
{
    detach();

    Node **node = findNode(akey);
    if (*node != e) {
        T t = (*node)->value;
        Node *next = (*node)->next;
        deleteNode(*node);
        *node = next;
        --d->size;
        d->hasShrunk();
        return t;
    }
    return T();
}

template <class Key, class T>
 typename QHash<Key, T>::iterator QHash<Key, T>::erase(iterator it)
{
    if (it == iterator(e))
        return it;

    iterator ret = it;
    ++ret;

    Node *node = it;
    Node **node_ptr = reinterpret_cast<Node **>(&d->buckets[node->h % d->numBuckets]);
    while (*node_ptr != node)
        node_ptr = &(*node_ptr)->next;
    *node_ptr = node->next;
    deleteNode(node);
    --d->size;
    return ret;
}

template <class Key, class T>
inline void QHash<Key, T>::reserve(int asize)
{
    detach();
    d->rehash(-qMax(asize, 1));
}

template <class Key, class T>
inline typename QHash<Key, T>::const_iterator QHash<Key, T>::find(const Key &akey) const
{
    return const_iterator(*findNode(akey));
}

template <class Key, class T>
inline typename QHash<Key, T>::const_iterator QHash<Key, T>::constFind(const Key &akey) const
{
    return const_iterator(*findNode(akey));
}

template <class Key, class T>
inline typename QHash<Key, T>::iterator QHash<Key, T>::find(const Key &akey)
{
    detach();
    return iterator(*findNode(akey));
}

template <class Key, class T>
inline bool QHash<Key, T>::contains(const Key &akey) const
{
    return *findNode(akey) != e;
}

template <class Key, class T>
 typename QHash<Key, T>::Node **QHash<Key, T>::findNode(const Key &akey,
                                                                            uint *ahp) const
{
    Node **node;
    uint h = qHash(akey);

    if (d->numBuckets) {
        node = reinterpret_cast<Node **>(&d->buckets[h % d->numBuckets]);
        while (*node != e && !(*node)->same_key(h, akey))
            node = &(*node)->next;
    } else {
        node = const_cast<Node **>(reinterpret_cast<const Node * const *>(&e));
    }
    if (ahp)
        *ahp = h;
    return node;
}

template <class Key, class T>
 bool QHash<Key, T>::operator==(const QHash<Key, T> &other) const
{
    if (size() != other.size())
        return false;
    if (d == other.d)
        return true;

    const_iterator it = begin();

    while (it != end()) {
        const Key &akey = it.key();

        const_iterator it2 = other.find(akey);
        do {
            if (it2 == other.end() || !(it2.key() == akey))
                return false;
            if (!QTypeInfo<T>::isDummy && !(it.value() == it2.value()))
                return false;
            ++it;
            ++it2;
        } while (it != end() && it.key() == akey);
    }
    return true;
}

template <class Key, class T>
class QMultiHash : public QHash<Key, T>
{
public:
    QMultiHash() {}
    QMultiHash(const QHash<Key, T> &other) : QHash<Key, T>(other) {}

    inline typename QHash<Key, T>::iterator replace(const Key &key, const T &value);
    inline typename QHash<Key, T>::iterator insert(const Key &key, const T &value);

    inline QMultiHash &operator+=(const QMultiHash &other)
    { unite(other); return *this; }
    inline QMultiHash operator+(const QMultiHash &other) const
    { QMultiHash result = *this; result += other; return result; }

private:
    T &operator[](const Key &key);
    const T operator[](const Key &key) const;
};

template <class Key, class T>
inline typename QHash<Key, T>::iterator QMultiHash<Key, T>::replace(const Key &akey, const T &avalue)
{ return QHash<Key, T>::insert(akey, avalue); }

template <class Key, class T>
inline typename QHash<Key, T>::iterator QMultiHash<Key, T>::insert(const Key &akey, const T &avalue)
{ return QHash<Key, T>::insertMulti(akey, avalue); }


template <class Key, class T> class QHashIterator { typedef typename QHash<Key,T> ::const_iterator const_iterator; typedef const_iterator Item; QHash<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c . constEnd(); } public: inline QHashIterator(const QHash<Key,T> &container) : c(container), i(c . constBegin()), n(c . constEnd()) {} inline QHashIterator &operator=(const QHash<Key,T> &container) { c = container; i = c . constBegin(); n = c . constEnd(); return *this; } inline void toFront() { i = c . constBegin(); n = c . constEnd(); } inline void toBack() { i = c . constEnd(); n = c . constEnd(); } inline bool hasNext() const { return i != c . constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c . constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qhash.h",812);} while (0); return *n; } inline const Key &key() const { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qhash.h",812);} while (0); return n . key(); } inline bool findNext(const T &t) { while ((n = i) != c . constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c . constBegin()) if (*(n = --i) == t) return true; n = c . constEnd(); return false; } };
template <class Key, class T> class QMutableHashIterator { typedef typename QHash<Key,T> ::iterator iterator; typedef iterator Item; QHash<Key,T> *c; iterator i, n; inline bool item_exists() const { return n != c->constEnd(); } public: inline QMutableHashIterator(QHash<Key,T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableHashIterator() { c->setSharable(true); } inline QMutableHashIterator &operator=(QHash<Key,T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return i != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (n != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (n != c->constEnd()) *n = t; } inline T &value() { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qhash.h",813);} while (0); return *n; } inline const T &value() const { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qhash.h",813);} while (0); return *n; } inline const Key &key() const { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qhash.h",813);} while (0); return n . key(); } inline bool findNext(const T &t) { while ((n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } };



#line 2 "../../include/QtCore/qhash.h"
#line 27 "../../include/QtCore/../../src/corelib/io/qdebug.h"
#line 1 "../../include/QtCore/qlist.h"
#line 28 "../../include/QtCore/../../src/corelib/io/qdebug.h"
#line 1 "../../include/QtCore/qmap.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qmap.h"



















 




#line 1 "../../include/QtCore/qatomic.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qmap.h"
#line 1 "../../include/QtCore/qiterator.h"
#line 27 "../../include/QtCore/../../src/corelib/tools/qmap.h"
#line 1 "../../include/QtCore/qlist.h"
#line 28 "../../include/QtCore/../../src/corelib/tools/qmap.h"

#line 1 "/usr/include/CC/map"

#line 1 "/usr/include/CC/xtree"

#line 1 "/usr/include/CC/stdexcept"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/stdexcept /main/1"

#line 7 "/usr/include/CC/xtree"

namespace std {

		
template<class _Traits>
	class _Tree_nod
		: public _Traits	
	{	
protected:
	typedef typename _Traits::allocator_type allocator_type;
	typedef typename _Traits::key_compare key_compare;
	typedef typename _Traits::value_type value_type;
	typedef typename allocator_type::template
		rebind<void>::other::pointer _Genptr;	

	struct _Node;
	friend struct _Node;
	struct _Node
		{	
		_Genptr _Left;	
		_Genptr _Parent;	
		_Genptr _Right;	
		value_type _Myval;	
		char _Color;	
		char _Isnil;	
		};

	_Tree_nod(const key_compare& _Parg,
		allocator_type _Al)
		: _Traits(_Parg), _Alnod(_Al)
		{}	

	typename allocator_type::template rebind<_Node>::other
		_Alnod;	
	};

		
template<class _Traits>
	class _Tree_ptr
		: public _Tree_nod<_Traits>
	{	
protected:
	typedef typename _Tree_nod<_Traits>::_Node _Node;
	typedef typename _Traits::allocator_type allocator_type;
	typedef typename _Traits::key_compare key_compare;
	typedef typename allocator_type::template
		rebind<_Node>::other::pointer _Nodeptr;

	_Tree_ptr(const key_compare& _Parg,
		allocator_type _Al)
		: _Tree_nod<_Traits>(_Parg, _Al), _Alptr(_Al)
		{}	

	typename allocator_type::template rebind<_Nodeptr>::other
		_Alptr;	
	};

		
template<class _Traits>
	class _Tree_val
		: public _Tree_ptr<_Traits>
	{	
protected:
	typedef typename _Traits::allocator_type allocator_type;
	typedef typename _Traits::key_compare key_compare;

	_Tree_val(const key_compare& _Parg,
		allocator_type _Al)
		: _Tree_ptr<_Traits>(_Parg, _Al), _Alval(_Al)
		{}	

	allocator_type _Alval;	
	};

		
template<class _Traits>
	class _Tree
		: public _Tree_val<_Traits>
	{	
public:
	typedef _Tree<_Traits> _Myt;
	typedef _Tree_val<_Traits> _Mybase;
	typedef typename _Traits::key_type key_type;
	typedef typename _Traits::key_compare key_compare;
	typedef typename _Traits::value_compare value_compare;
	typedef typename _Traits::value_type value_type;
	typedef typename _Traits::allocator_type allocator_type;
	typedef typename _Traits::_ITptr _ITptr;
	typedef typename _Traits::_IReft _IReft;

protected:
	typedef typename _Tree_nod<_Traits>::_Genptr _Genptr;
	typedef typename _Tree_nod<_Traits>::_Node _Node;

	enum _Redbl
		{	
		_Red, _Black};
	typedef typename allocator_type::template rebind<_Node> ::other::pointer _Nodeptr;
	typedef typename allocator_type::template rebind<_Nodeptr> ::other::reference _Nodepref;
	typedef typename allocator_type::template rebind<key_type> ::other::const_reference _Keyref;
	typedef typename allocator_type::template rebind<char> ::other::reference _Charref;
	typedef typename allocator_type::template rebind<value_type> ::other::reference _Vref;

	static _Charref _Color(_Nodeptr _Pnode)
		{	
		return ((_Charref)(*_Pnode)._Color); }

	static _Charref _Isnil(_Nodeptr _Pnode)
		{	
		return ((_Charref)(*_Pnode)._Isnil); }

	static _Keyref _Key(_Nodeptr _Pnode)
		{	
		return (_Kfn()(_Myval(_Pnode))); }

	static _Nodepref _Left(_Nodeptr _Pnode)
		{	
		return ((_Nodepref)(*_Pnode)._Left); }

	static _Nodepref _Parent(_Nodeptr _Pnode)
		{	
		return ((_Nodepref)(*_Pnode)._Parent); }

	static _Nodepref _Right(_Nodeptr _Pnode)
		{	
		return ((_Nodepref)(*_Pnode)._Right); }

	static _Vref _Myval(_Nodeptr _Pnode)
		{	
		return ((_Vref)(*_Pnode)._Myval); }

public:
	typedef typename allocator_type::size_type size_type;
	typedef typename allocator_type::difference_type _Dift;
	typedef _Dift difference_type;
	typedef typename allocator_type::template rebind<value_type> ::other::pointer _Tptr;
	typedef typename allocator_type::template rebind<value_type> ::other::const_pointer _Ctptr;
	typedef typename allocator_type::template rebind<value_type> ::other::reference _Reft;
	typedef _Tptr pointer;
	typedef _Ctptr const_pointer;
	typedef _Reft reference;
	typedef typename allocator_type::template rebind<value_type> ::other::const_reference
		const_reference;

		
	class const_iterator;
	friend class const_iterator;

	class const_iterator
		: public _Bidit<value_type, _Dift, _Ctptr, const_reference>
	{	
	public:
		typedef bidirectional_iterator_tag iterator_category;
		typedef _Dift difference_type;
		typedef _Ctptr pointer;
		typedef const_reference reference;

		const_iterator()
			: _Ptr(0)
			{}	

		const_iterator(_Nodeptr _Pnode)
			: _Ptr(_Pnode)
			{}	

		const_reference operator*() const
			{	
			return (_Myval(_Ptr)); }

		_Ctptr operator->() const
			{	
			return (&**this); }

		const_iterator& operator++()
			{	
			_Inc();
			return (*this); }

		const_iterator operator++(int)
			{	
			const_iterator _Tmp = *this;
			++*this;
			return (_Tmp); }

		const_iterator& operator--()
			{	
			_Dec();
			return (*this); }

		const_iterator operator--(int)
			{	
			const_iterator _Tmp = *this;
			--*this;
			return (_Tmp); }

		bool operator==(const const_iterator& _Right) const
			{	
			return (_Ptr == _Right._Ptr); }

		bool operator!=(const const_iterator& _Right) const
			{	
			return (!(*this == _Right)); }

		void _Dec()
			{	
			if (_Isnil(_Ptr))
				_Ptr = _Right(_Ptr);	
			else if (!_Isnil(_Left(_Ptr)))
				_Ptr = _Max(_Left(_Ptr));	
			else
				{	
				_Nodeptr _Pnode;
				while (!_Isnil(_Pnode = _Parent(_Ptr))
					&& _Ptr == _Left(_Pnode))
					_Ptr = _Pnode;	
				if (!_Isnil(_Pnode))
					_Ptr = _Pnode; }}	

		void _Inc()
			{	
			if (_Isnil(_Ptr))
				;	
			else if (!_Isnil(_Right(_Ptr)))
				_Ptr = _Min(_Right(_Ptr));	
			else
				{	
				_Nodeptr _Pnode;
				while (!_Isnil(_Pnode = _Parent(_Ptr))
					&& _Ptr == _Right(_Pnode))
					_Ptr = _Pnode;	
				_Ptr = _Pnode; }}	

		_Nodeptr _Mynode() const
			{	
			return (_Ptr); }

	protected:
		_Nodeptr _Ptr;	
		};

		
	class iterator;
	friend class iterator;

	class iterator
		: public const_iterator
	{	
	public:
		typedef bidirectional_iterator_tag iterator_category;
		typedef _Dift difference_type;
		typedef _ITptr pointer;
		typedef _IReft reference;

		iterator()
			: const_iterator(0)
			{}	

		iterator(_Nodeptr _Pnode)
			: const_iterator(_Pnode)
			{}	

		reference operator*() const
			{	
			return (_Myval(_Ptr)); }

		pointer operator->() const
			{	
			return (&**this); }

		iterator& operator++()
			{	
			_Inc();
			return (*this); }

		iterator operator++(int)
			{	
			iterator _Tmp = *this;
			++*this;
			return (_Tmp); }

		iterator& operator--()
			{	
			_Dec();
			return (*this); }

		iterator operator--(int)
			{	
			iterator _Tmp = *this;
			--*this;
			return (_Tmp); }
		};

	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
	typedef pair<iterator, bool> _Pairib;
	typedef pair<iterator, iterator> _Pairii;
	typedef pair<const_iterator, const_iterator> _Paircc;

	explicit _Tree(const key_compare& _Parg,
		const allocator_type& _Al)
		: _Mybase(_Parg, _Al)
		{	
		_Init(); }

	_Tree(const value_type *_First, const value_type *_Last,
		const key_compare& _Parg, const allocator_type& _Al)
		: _Mybase(_Parg, _Al)
		{	
		_Init();
		insert(_First, _Last); }

	_Tree(const _Myt& _Right)
		: _Mybase(_Right.key_comp(), _Right.get_allocator())
		{	
		_Init();
		_Copy(_Right); }

	~_Tree()
		{	
		erase(begin(), end());
		_Freenode(_Myhead);
		_Myhead = 0, _Mysize = 0; }

	_Myt& operator=(const _Myt& _Right)
		{	
		if (this != &_Right)
			{	
			erase(begin(), end());
			comp = _Right.comp;
			_Copy(_Right); }
		return (*this); }

	iterator begin()
		{	
		return (iterator(_Lmost())); }

	const_iterator begin() const
		{	
		return (const_iterator(_Lmost())); }

	iterator end()
		{	
		return (iterator(_Myhead)); }

	const_iterator end() const
		{	
		return (const_iterator(_Myhead)); }

	reverse_iterator rbegin()
		{	
		return (reverse_iterator(end())); }

	const_reverse_iterator rbegin() const
		{	
		return (const_reverse_iterator(end())); }

	reverse_iterator rend()
		{	
		return (reverse_iterator(begin())); }

	const_reverse_iterator rend() const
		{	
		return (const_reverse_iterator(begin())); }

	size_type size() const
		{	
		return (_Mysize); }

	size_type max_size() const
		{	
		return (_Alval.max_size()); }

	bool empty() const
		{	
		return (size() == 0); }

	allocator_type get_allocator() const
		{	
		return (_Alval); }

	key_compare key_comp() const
		{	
		return (comp); }

	value_compare value_comp() const
		{	
		return (value_compare(key_comp())); }

	_Pairib insert(const value_type& _Val)
		{	
		_Nodeptr _Trynode = _Root();
		_Nodeptr _Wherenode = _Myhead;
		bool _Addleft = true;	
		while (!_Isnil(_Trynode))
			{	
			_Wherenode = _Trynode;
			_Addleft = comp(_Kfn()(_Val), _Key(_Trynode));
			_Trynode = _Addleft ? _Left(_Trynode) : _Right(_Trynode); }

		if (_Multi)
			return (_Pairib(_Insert(_Addleft, _Wherenode, _Val), true));
		else
			{	
			iterator _Where = iterator(_Wherenode);
			if (!_Addleft)
				;	
			else if (_Where == begin())
				return (_Pairib(_Insert(true, _Wherenode, _Val), true));
			else
				--_Where;	

			if (comp(_Key(_Where._Mynode()), _Kfn()(_Val)))
				return (_Pairib(_Insert(_Addleft, _Wherenode, _Val), true));
			else
				return (_Pairib(_Where, false)); }}

	iterator insert(iterator _Where, const value_type& _Val)
		{	
		if (size() == 0)
			return (_Insert(true, _Myhead, _Val));	
		else if (_Multi)
			{	
			if (_Where == begin())
				{	
				if (!comp(_Key(_Where._Mynode()), _Kfn()(_Val)))
					return (_Insert(true, _Where._Mynode(), _Val)); }
			else if (_Where == end())
				{	
				if (!comp(_Kfn()(_Val), _Key(_Rmost())))
					return (_Insert(false, _Rmost(), _Val)); }
			else
				{	
				iterator _Before = _Where;
				if ((comp(_Kfn()(_Val), _Key((_Before)._Mynode()))
						|| comp(_Key(_Where._Mynode()), _Kfn()(_Val)))
					&& (comp(_Kfn()(_Val), _Key((--_Before)._Mynode()))
						|| comp(_Key(_Where._Mynode()), _Kfn()(_Val))))
					;	
				else if (_Isnil(_Right(_Before._Mynode())))
					return (_Insert(false, _Before._Mynode(), _Val));
				else
					return (_Insert(true, _Where._Mynode(), _Val)); }}
		else
			{	
			if (_Where == begin())
				{	
				if (comp(_Kfn()(_Val), _Key(_Where._Mynode())))
					return (_Insert(true, _Where._Mynode(), _Val)); }
			else if (_Where == end())
				{	
				if (comp(_Key(_Rmost()), _Kfn()(_Val)))
					return (_Insert(false, _Rmost(), _Val)); }
			else
				{	
				iterator _Before = _Where;
				if (!comp(_Key((--_Before)._Mynode()), _Kfn()(_Val))
					|| !comp(_Kfn()(_Val), _Key(_Where._Mynode())))
					;	
				else if (_Isnil(_Right(_Before._Mynode())))
					return (_Insert(false, _Before._Mynode(), _Val));
				else
					return (_Insert(true, _Where._Mynode(), _Val)); }}

		return (insert(_Val).first); }	

	template<class _Iter>
		void insert(_Iter _First, _Iter _Last)
		{	
		for (; _First != _Last; ++_First)
			insert(*_First); }

	iterator erase(iterator _Where)
		{	
		if (_Isnil(_Where._Mynode()))
			throw out_of_range("invalid map/set<T> iterator");
		_Nodeptr _Fixnode;	
		_Nodeptr _Fixnodeparent;	
		_Nodeptr _Erasednode = _Where._Mynode();	
		_Nodeptr _Pnode = _Erasednode;
		++_Where;	

		if (_Isnil(_Left(_Pnode)))
			_Fixnode = _Right(_Pnode);	
		else if (_Isnil(_Right(_Pnode)))
			_Fixnode = _Left(_Pnode);	
		else
			{	
			_Pnode = _Where._Mynode();	
			_Fixnode = _Right(_Pnode); }	

		if (_Pnode == _Erasednode)
			{	
			_Fixnodeparent = _Parent(_Erasednode);
			if (!_Isnil(_Fixnode))
				_Parent(_Fixnode) = _Fixnodeparent;	

			if (_Root() == _Erasednode)
				_Root() = _Fixnode;	
			else if (_Left(_Fixnodeparent) == _Erasednode)
				_Left(_Fixnodeparent) = _Fixnode;	
			else
				_Right(_Fixnodeparent) = _Fixnode;	

			if (_Lmost() == _Erasednode)
				_Lmost() = _Isnil(_Fixnode)
					? _Fixnodeparent	
					: _Min(_Fixnode);	

			if (_Rmost() == _Erasednode)
				_Rmost() = _Isnil(_Fixnode)
					? _Fixnodeparent	
					: _Max(_Fixnode); }	
		else
			{	
			_Parent(_Left(_Erasednode)) = _Pnode;	
			_Left(_Pnode) = _Left(_Erasednode);	

			if (_Pnode == _Right(_Erasednode))
				_Fixnodeparent = _Pnode;	
			else
				{	
				_Fixnodeparent = _Parent(_Pnode);	
				if (!_Isnil(_Fixnode))
					_Parent(_Fixnode) = _Fixnodeparent;	
				_Left(_Fixnodeparent) = _Fixnode;	
				_Right(_Pnode) = _Right(_Erasednode);	
				_Parent(_Right(_Erasednode)) = _Pnode; }	

			if (_Root() == _Erasednode)
				_Root() = _Pnode;	
			else if (_Left(_Parent(_Erasednode)) == _Erasednode)
				_Left(_Parent(_Erasednode)) = _Pnode;	
			else
				_Right(_Parent(_Erasednode)) = _Pnode;	

			_Parent(_Pnode) = _Parent(_Erasednode);	
			std::swap(_Color(_Pnode), _Color(_Erasednode)); }	

		if (_Color(_Erasednode) == _Black)
			{	
			for (; _Fixnode != _Root() && _Color(_Fixnode) == _Black;
				_Fixnodeparent = _Parent(_Fixnode))
				if (_Fixnode == _Left(_Fixnodeparent))
					{	
					_Pnode = _Right(_Fixnodeparent);
					if (_Color(_Pnode) == _Red)
						{	
						_Color(_Pnode) = _Black;
						_Color(_Fixnodeparent) = _Red;
						_Lrotate(_Fixnodeparent);
						_Pnode = _Right(_Fixnodeparent); }

					if (_Isnil(_Pnode))
						_Fixnode = _Fixnodeparent;	
					else if (_Color(_Left(_Pnode)) == _Black
						&& _Color(_Right(_Pnode)) == _Black)
						{	
						_Color(_Pnode) = _Red;
						_Fixnode = _Fixnodeparent; }
					else
						{	
						if (_Color(_Right(_Pnode)) == _Black)
							{	
							_Color(_Left(_Pnode)) = _Black;
							_Color(_Pnode) = _Red;
							_Rrotate(_Pnode);
							_Pnode = _Right(_Fixnodeparent); }

						_Color(_Pnode) = _Color(_Fixnodeparent);
						_Color(_Fixnodeparent) = _Black;
						_Color(_Right(_Pnode)) = _Black;
						_Lrotate(_Fixnodeparent);
						break; }}	
				else
					{	
					_Pnode = _Left(_Fixnodeparent);
					if (_Color(_Pnode) == _Red)
						{	
						_Color(_Pnode) = _Black;
						_Color(_Fixnodeparent) = _Red;
						_Rrotate(_Fixnodeparent);
						_Pnode = _Left(_Fixnodeparent); }
					if (_Isnil(_Pnode))
						_Fixnode = _Fixnodeparent;	
					else if (_Color(_Right(_Pnode)) == _Black
						&& _Color(_Left(_Pnode)) == _Black)
						{	
						_Color(_Pnode) = _Red;
						_Fixnode = _Fixnodeparent; }
					else
						{	
						if (_Color(_Left(_Pnode)) == _Black)
							{	
							_Color(_Right(_Pnode)) = _Black;
							_Color(_Pnode) = _Red;
							_Lrotate(_Pnode);
							_Pnode = _Left(_Fixnodeparent); }

						_Color(_Pnode) = _Color(_Fixnodeparent);
						_Color(_Fixnodeparent) = _Black;
						_Color(_Left(_Pnode)) = _Black;
						_Rrotate(_Fixnodeparent);
						break; }}	

			_Color(_Fixnode) = _Black; }	

		_Destval(&_Myval(_Erasednode));	
		_Freenode(_Erasednode);
		if (0 < _Mysize)
			--_Mysize;

		return (_Where); }	

	iterator erase(iterator _First, iterator _Last)
		{	
		if (_First == begin() && _Last == end())
			{	
			clear();
			return (begin()); }
		else
			{	
			while (_First != _Last)
				erase(_First++);
			return (_First); }}

	size_type erase(const key_type& _Keyval)
		{	
		_Pairii _Where = equal_range(_Keyval);
		size_type _Num = 0;
		_Distance(_Where.first, _Where.second, _Num);
		erase(_Where.first, _Where.second);
		return (_Num); }

	void erase(const key_type *_First, const key_type *_Last)
		{	
		while (_First != _Last)
			erase(*_First++); }

	void clear()
		{	
		_Erase(_Root());
		_Root() = _Myhead, _Mysize = 0;
		_Lmost() = _Myhead, _Rmost() = _Myhead; }

	iterator find(const key_type& _Keyval)
		{	
		iterator _Where = lower_bound(_Keyval);
		return (_Where == end() || comp(_Keyval, _Key(_Where._Mynode()))
			? end() : _Where); }

	const_iterator find(const key_type& _Keyval) const
		{	
		const_iterator _Where = lower_bound(_Keyval);
		return (_Where == end() || comp(_Keyval, _Key(_Where._Mynode()))
			? end() : _Where); }

	size_type count(const key_type& _Keyval) const
		{	
		_Paircc _Ans = equal_range(_Keyval);
		size_type _Num = 0;
		_Distance(_Ans.first, _Ans.second, _Num);
		return (_Num); }

	iterator lower_bound(const key_type& _Keyval)
		{	
		return (iterator(_Lbound(_Keyval))); }

	const_iterator lower_bound(const key_type& _Keyval) const
		{	
		return (const_iterator(_Lbound(_Keyval))); }

	iterator upper_bound(const key_type& _Keyval)
		{	
		return (iterator(_Ubound(_Keyval))); }

	const_iterator upper_bound(const key_type& _Keyval) const
		{	
		return (const_iterator(_Ubound(_Keyval))); }

	_Pairii equal_range(const key_type& _Keyval)
		{	
		return (_Pairii(lower_bound(_Keyval), upper_bound(_Keyval))); }

	_Paircc equal_range(const key_type& _Keyval) const
		{	
		return (_Paircc(lower_bound(_Keyval), upper_bound(_Keyval))); }

	void swap(_Myt& _Right)
		{	
		if (get_allocator() == _Right.get_allocator())
			{	
			std::swap(comp, _Right.comp);
			std::swap(_Myhead, _Right._Myhead);
			std::swap(_Mysize, _Right._Mysize); }
		else
			{	
			_Myt _Tmp = *this; *this = _Right, _Right = _Tmp; }}

protected:
	void _Copy(const _Myt& _Right)
		{	
		_Root() = _Copy(_Right._Root(), _Myhead);
		_Mysize = _Right.size();
		if (!_Isnil(_Root()))
			{	
			_Lmost() = _Min(_Root());
			_Rmost() = _Max(_Root()); }
		else
			_Lmost() = _Myhead, _Rmost() = _Myhead; }	

	_Nodeptr _Copy(_Nodeptr _Rootnode, _Nodeptr _Wherenode)
		{	
		_Nodeptr _Newroot = _Myhead;	

		if (!_Isnil(_Rootnode))
			{	
			_Nodeptr _Pnode = _Buynode(_Wherenode, _Color(_Rootnode));

			try {
			_Consval(&_Myval(_Pnode), _Myval(_Rootnode));
			 } catch (...) {
			_Freenode(_Pnode);	
			_Erase(_Newroot);
			throw;
			}

			_Left(_Pnode) = _Myhead;	
			_Right(_Pnode) = _Myhead;	
			if (_Isnil(_Newroot))
				_Newroot = _Pnode;	

			try {
			_Left(_Pnode) = _Copy(_Left(_Rootnode), _Pnode);
			_Right(_Pnode) = _Copy(_Right(_Rootnode), _Pnode);
			 } catch (...) {
			_Erase(_Newroot);	
			throw;
			}}

		return (_Newroot); }	

	void _Erase(_Nodeptr _Rootnode)
		{	
		for (_Nodeptr _Pnode = _Rootnode; !_Isnil(_Pnode); _Rootnode = _Pnode)
			{	
			_Erase(_Right(_Pnode));
			_Pnode = _Left(_Pnode);
			_Destval(&_Myval(_Rootnode));
			_Freenode(_Rootnode); }}

	void _Init()
		{	
		_Myhead = _Buynode(0, _Black);
		_Isnil(_Myhead) = true;
		_Root() = _Myhead;
		_Lmost() = _Myhead, _Rmost() = _Myhead;
		_Mysize = 0; }

	iterator _Insert(bool _Addleft, _Nodeptr _Wherenode,
		const value_type& _Val)
		{	
		if (max_size() - 1 <= _Mysize)
			throw length_error("map/set<T> too long");
		_Nodeptr _Newnode = _Buynode(_Wherenode, _Red);
		_Left(_Newnode) = _Myhead, _Right(_Newnode) = _Myhead;

		try {
		_Consval(&_Myval(_Newnode), _Val);
		 } catch (...) {
		_Freenode(_Newnode);	
		throw;
		}

		++_Mysize;
		if (_Wherenode == _Myhead)
			{	
			_Root() = _Newnode;
			_Lmost() = _Newnode, _Rmost() = _Newnode; }
		else if (_Addleft)
			{	
			_Left(_Wherenode) = _Newnode;
			if (_Wherenode == _Lmost())
				_Lmost() = _Newnode; }
		else
			{	
			_Right(_Wherenode) = _Newnode;
			if (_Wherenode == _Rmost())
				_Rmost() = _Newnode; }

		for (_Nodeptr _Pnode = _Newnode; _Color(_Parent(_Pnode)) == _Red; )
			if (_Parent(_Pnode) == _Left(_Parent(_Parent(_Pnode))))
				{	
				_Wherenode = _Right(_Parent(_Parent(_Pnode)));
				if (_Color(_Wherenode) == _Red)
					{	
					_Color(_Parent(_Pnode)) = _Black;
					_Color(_Wherenode) = _Black;
					_Color(_Parent(_Parent(_Pnode))) = _Red;
					_Pnode = _Parent(_Parent(_Pnode)); }
				else
					{	
					if (_Pnode == _Right(_Parent(_Pnode)))
						{	
						_Pnode = _Parent(_Pnode);
						_Lrotate(_Pnode); }
					_Color(_Parent(_Pnode)) = _Black;	
					_Color(_Parent(_Parent(_Pnode))) = _Red;
					_Rrotate(_Parent(_Parent(_Pnode))); }}
			else
				{	
				_Wherenode = _Left(_Parent(_Parent(_Pnode)));
				if (_Color(_Wherenode) == _Red)
					{	
					_Color(_Parent(_Pnode)) = _Black;
					_Color(_Wherenode) = _Black;
					_Color(_Parent(_Parent(_Pnode))) = _Red;
					_Pnode = _Parent(_Parent(_Pnode)); }
				else
					{	
					if (_Pnode == _Left(_Parent(_Pnode)))
						{	
						_Pnode = _Parent(_Pnode);
						_Rrotate(_Pnode); }
					_Color(_Parent(_Pnode)) = _Black;	
					_Color(_Parent(_Parent(_Pnode))) = _Red;
					_Lrotate(_Parent(_Parent(_Pnode))); }}

		_Color(_Root()) = _Black;	
		return (iterator(_Newnode)); }

	_Nodeptr _Lbound(const key_type& _Keyval) const
		{	
		_Nodeptr _Pnode = _Root();
		_Nodeptr _Wherenode = _Myhead;	

		while (!_Isnil(_Pnode))
			if (comp(_Key(_Pnode), _Keyval))
				_Pnode = _Right(_Pnode);	
			else
				{	
				_Wherenode = _Pnode;
				_Pnode = _Left(_Pnode); }	

		return (_Wherenode); }	

	_Nodeptr& _Lmost()
		{	
		return (_Left(_Myhead)); }

	_Nodeptr& _Lmost() const
		{	
		return (_Left(_Myhead)); }

	void _Lrotate(_Nodeptr _Wherenode)
		{	
		_Nodeptr _Pnode = _Right(_Wherenode);
		_Right(_Wherenode) = _Left(_Pnode);

		if (!_Isnil(_Left(_Pnode)))
			_Parent(_Left(_Pnode)) = _Wherenode;
		_Parent(_Pnode) = _Parent(_Wherenode);

		if (_Wherenode == _Root())
			_Root() = _Pnode;
		else if (_Wherenode == _Left(_Parent(_Wherenode)))
			_Left(_Parent(_Wherenode)) = _Pnode;
		else
			_Right(_Parent(_Wherenode)) = _Pnode;

		_Left(_Pnode) = _Wherenode;
		_Parent(_Wherenode) = _Pnode; }

	static _Nodeptr _Max(_Nodeptr _Pnode)
		{	
		while (!_Isnil(_Right(_Pnode)))
			_Pnode = _Right(_Pnode);
		return (_Pnode); }

	static _Nodeptr _Min(_Nodeptr _Pnode)
		{	
		while (!_Isnil(_Left(_Pnode)))
			_Pnode = _Left(_Pnode);
		return (_Pnode); }

	_Nodeptr& _Rmost()
		{	
		return (_Right(_Myhead)); }

	_Nodeptr& _Rmost() const
		{	
		return (_Right(_Myhead)); }

	_Nodeptr& _Root()
		{	
		return (_Parent(_Myhead)); }

	_Nodeptr& _Root() const
		{	
		return (_Parent(_Myhead)); }

	void _Rrotate(_Nodeptr _Wherenode)
		{	
		_Nodeptr _Pnode = _Left(_Wherenode);
		_Left(_Wherenode) = _Right(_Pnode);

		if (!_Isnil(_Right(_Pnode)))
			_Parent(_Right(_Pnode)) = _Wherenode;
		_Parent(_Pnode) = _Parent(_Wherenode);

		if (_Wherenode == _Root())
			_Root() = _Pnode;
		else if (_Wherenode == _Right(_Parent(_Wherenode)))
			_Right(_Parent(_Wherenode)) = _Pnode;
		else
			_Left(_Parent(_Wherenode)) = _Pnode;

		_Right(_Pnode) = _Wherenode;
		_Parent(_Wherenode) = _Pnode; }

	_Nodeptr _Ubound(const key_type& _Keyval) const
		{	
		_Nodeptr _Pnode = _Root();
		_Nodeptr _Wherenode = _Myhead;	

		while (!_Isnil(_Pnode))
			if (comp(_Keyval, _Key(_Pnode)))
				{	
				_Wherenode = _Pnode;
				_Pnode = _Left(_Pnode); }	
			else
				_Pnode = _Right(_Pnode);	

		return (_Wherenode); }	

	_Nodeptr _Buynode(_Nodeptr _Parg, char _Carg)
		{	
		_Nodeptr _Wherenode = _Alnod.allocate(1, (void *)0);
		_Alptr.construct(&_Left(_Wherenode), 0);
		_Alptr.construct(&_Right(_Wherenode), 0);
		_Alptr.construct(&_Parent(_Wherenode), _Parg);
		_Color(_Wherenode) = _Carg;
		_Isnil(_Wherenode) = false;
		return (_Wherenode); }

	void _Consval(_Tptr _Pval, const value_type& _Val)
		{	
		_Alval.construct(_Pval, _Val); }

	void _Freenode(_Nodeptr _Wherenode)
		{	
		_Alptr.destroy(&_Parent(_Wherenode));
		_Alptr.destroy(&_Right(_Wherenode));
		_Alptr.destroy(&_Left(_Wherenode));
		_Alnod.deallocate(_Wherenode, 1); }

	void _Destval(_Tptr _Pval)
		{	
		_Alval.destroy(_Pval); }

	_Nodeptr _Myhead;	
	size_type _Mysize;	
	};

		
template<class _Traits> inline
	void swap(_Tree<_Traits>& _Left, _Tree<_Traits>& _Right)
	{	
	_Left.swap(_Right); }

template<class _Traits> inline
	bool operator==(const _Tree<_Traits>& _Left, const _Tree<_Traits>& _Right)
	{	
	return (_Left.size() == _Right.size()
		&& equal(_Left.begin(), _Left.end(), _Right.begin())); }

template<class _Traits> inline
	bool operator!=(const _Tree<_Traits>& _Left, const _Tree<_Traits>& _Right)
	{	
	return (!(_Left == _Right)); }

template<class _Traits> inline
	bool operator<(const _Tree<_Traits>& _Left, const _Tree<_Traits>& _Right)
	{	
	return (lexicographical_compare(_Left.begin(), _Left.end(),
		_Right.begin(), _Right.end(), _Left.value_comp())); }

template<class _Traits> inline
	bool operator>(const _Tree<_Traits>& _Left, const _Tree<_Traits>& _Right)
	{	
	return (_Right < _Left); }

template<class _Traits> inline
	bool operator<=(const _Tree<_Traits>& _Left, const _Tree<_Traits>& _Right)
	{	
	return (!(_Right < _Left)); }

template<class _Traits> inline
	bool operator>=(const _Tree<_Traits>& _Left, const _Tree<_Traits>& _Right)
	{	
	return (!(_Left < _Right)); }

}	





 
















 
#line 5 "/usr/include/CC/map"

namespace std {

		
template<class _Kty,	
	class _Ty,	
	class _Pr,	
	class _Alloc,	
	bool _Mfl>	
	class _Tmap_traits
	{	
public:
	typedef _Kty key_type;
	typedef pair<const _Kty, _Ty> value_type;
	typedef _Pr key_compare;
	typedef typename _Alloc::template rebind<value_type>::other
		allocator_type;
	typedef typename allocator_type::template rebind<value_type> ::other::pointer _ITptr;
	typedef typename allocator_type::template rebind<value_type> ::other::reference _IReft;
	enum
		{	
		_Multi = _Mfl};

	_Tmap_traits()
		: comp()
		{}	

	_Tmap_traits(_Pr _Parg)
		: comp(_Parg)
		{}	

	class value_compare
		: public binary_function<value_type, value_type, bool>
		{	
		friend class _Tmap_traits<_Kty, _Ty, _Pr, _Alloc, _Mfl>;

	public:
		bool operator()(const value_type& _Left,
			const value_type& _Right) const
			{	
			return (comp(_Left.first, _Right.first)); }

		value_compare(key_compare _Pred)
			: comp(_Pred)
			{}	

	protected:
		key_compare comp;	
		};

	struct _Kfn
		{	
		const _Kty& operator()(const value_type& _Val) const
			{	
			return (_Val.first); }
		};

	_Pr comp;	
	};

		
template<class _Kty,
	class _Ty,
	class _Pr = less<_Kty>,
	class _Alloc = allocator<pair<const _Kty, _Ty> > >
	class map
		: public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> >
	{	
public:
	typedef map<_Kty, _Ty, _Pr, _Alloc> _Myt;
	typedef _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> > _Mybase;
	typedef _Kty key_type;
	typedef _Ty mapped_type;
	typedef _Pr key_compare;
	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
	typedef typename _Mybase::reverse_iterator reverse_iterator;
	typedef typename _Mybase::const_reverse_iterator
		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	map()
		: _Mybase(key_compare(), allocator_type())
		{}	

	explicit map(const key_compare& _Pred)
		: _Mybase(_Pred, allocator_type())
		{}	

	map(const key_compare& _Pred, const allocator_type& _Al)
		: _Mybase(_Pred, _Al)
		{}	

	template<class _Iter>
		map(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	
		for (; _First != _Last; ++_First)
			insert(*_First); }

	template<class _Iter>
		map(_Iter _First, _Iter _Last, const key_compare& _Pred)
		: _Mybase(_Pred, allocator_type())
		{	
		for (; _First != _Last; ++_First)
			insert(*_First); }

	template<class _Iter>
		map(_Iter _First, _Iter _Last, const key_compare& _Pred,
		const allocator_type& _Al)
		: _Mybase(_Pred, _Al)
		{	
		for (; _First != _Last; ++_First)
			insert(*_First); }

	mapped_type& operator[](const key_type& _Keyval)
		{	
		iterator _Where =
			insert(value_type(_Keyval, mapped_type())).first;
		return ((*_Where).second); }
	};

		
template<class _Kty,
	class _Ty,
	class _Pr = less<_Kty>,
	class _Alloc = allocator<pair<const _Kty, _Ty> > >
	class multimap
		: public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true> >
	{	
public:
	typedef multimap<_Kty, _Ty, _Pr, _Alloc> _Myt;
	typedef _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true> > _Mybase;
	typedef _Kty key_type;
	typedef _Ty mapped_type;
	typedef _Pr key_compare;
	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
	typedef typename _Mybase::reverse_iterator reverse_iterator;
	typedef typename _Mybase::const_reverse_iterator
		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	multimap()
		: _Mybase(key_compare(), allocator_type())
		{}	

	explicit multimap(const key_compare& _Pred)
		: _Mybase(_Pred, allocator_type())
		{}	
	multimap(const key_compare& _Pred, const allocator_type& _Al)
		: _Mybase(_Pred, _Al)
		{}	

	template<class _Iter>
		multimap(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	
		for (; _First != _Last; ++_First)
			insert(*_First); }

	template<class _Iter>
		multimap(_Iter _First, _Iter _Last, const key_compare& _Pred)
		: _Mybase(_Pred, allocator_type())
		{	
		for (; _First != _Last; ++_First)
			insert(*_First); }

	template<class _Iter>
		multimap(_Iter _First, _Iter _Last, const key_compare& _Pred,
		const allocator_type& _Al)
		: _Mybase(_Pred, _Al)
		{	
		for (; _First != _Last; ++_First)
			insert(*_First); }

	iterator insert(const value_type& _Val)
		{	
		return (_Mybase::insert(_Val).first); }

	iterator insert(iterator _Where, const value_type& _Val)
		{	
		return (_Mybase::insert(_Where, _Val)); }

	template<class _Iter>
		void insert(_Iter _First, _Iter _Last)
		{	
		for (; _First != _Last; ++_First)
			insert(*_First); }
	};

}	





 
#line 31 "../../include/QtCore/../../src/corelib/tools/qmap.h"


#line 1 "/usr/include/CC/new"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/new /main/1"

 


 

#line 34 "../../include/QtCore/../../src/corelib/tools/qmap.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

struct  QMapData
{
    struct Node {
        Node *backward;
        Node *forward[1];
    };
    enum { LastLevel = 11, Sparseness = 3 };

    Node *backward;
    Node *forward[QMapData::LastLevel + 1];
    QBasicAtomic ref;
    int topLevel;
    int size;
    uint randomBits;
    uint insertInOrder : 1;
    uint sharable : 1;

    static QMapData *createData();
    void continueFreeData(int offset);
    Node *node_create(Node *update[], int offset);
    void node_delete(Node *update[], int offset, Node *node);





    static QMapData shared_null;
};










 

template <class Key> inline bool qMapLessThanKey(const Key &key1, const Key &key2)
{
    return key1 < key2;
}


template <class Ptr> inline bool qMapLessThanKey(Ptr *key1, Ptr *key2)
{
    do {if(!(sizeof(ulong) == sizeof(Ptr *)))qt_assert("sizeof(ulong) == sizeof(Ptr *)","../../include/QtCore/../../src/corelib/tools/qmap.h",87);} while (0);
    return reinterpret_cast<ulong>(key1) < reinterpret_cast<ulong>(key2);
}

template <class Ptr> inline bool qMapLessThanKey(const Ptr *key1, const Ptr *key2)
{
    do {if(!(sizeof(ulong) == sizeof(const Ptr *)))qt_assert("sizeof(ulong) == sizeof(const Ptr *)","../../include/QtCore/../../src/corelib/tools/qmap.h",93);} while (0);
    return reinterpret_cast<ulong>(key1) < reinterpret_cast<ulong>(key2);
}



class QDataStream;
template <class Key, class T> class QMap;
template <class aKey, class aT>
QDataStream &operator>>(QDataStream &in, QMap<aKey, aT> &map);


template <class Key, class T>
class QMap
{
    struct Node {
        Key key;
        T value;
        QMapData::Node *backward;
        QMapData::Node *forward[1];
    };
    union {
        QMapData *d;
        QMapData::Node *e;
    };

    struct PayloadNode
    {
        Key key;
        T value;
        QMapData::Node *backward;
    };
    enum { Payload = sizeof(PayloadNode) - sizeof(QMapData::Node *) };

    static inline Node *concrete(QMapData::Node *node) {
        return reinterpret_cast<Node *>(reinterpret_cast<char *>(node) - Payload);
    }
public:
    inline QMap() : d(&QMapData::shared_null) { d->ref.ref(); }
    inline QMap(const QMap<Key, T> &other) : d(other.d)
    { d->ref.ref(); if (!d->sharable) detach(); }
    inline ~QMap() { if (!d) return; if (!d->ref.deref()) freeData(d); }

    QMap<Key, T> &operator=(const QMap<Key, T> &other);

    explicit QMap(const typename std::map<Key, T> &other);
    std::map<Key, T> toStdMap() const;


    bool operator==(const QMap<Key, T> &other) const;
    inline bool operator!=(const QMap<Key, T> &other) const { return !(*this == other); }

    inline int size() const { return d->size; }

    inline bool isEmpty() const { return d->size == 0; }

    inline void detach() { if (d->ref != 1) detach_helper(); }
    inline bool isDetached() const { return d->ref == 1; }
    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }

    void clear();

    int remove(const Key &key);
    T take(const Key &key);

    bool contains(const Key &key) const;
    const Key key(const T &value) const;
    const T value(const Key &key) const;
    const T value(const Key &key, const T &defaultValue) const;
    T &operator[](const Key &key);
    const T operator[](const Key &key) const;

    QList<Key> keys() const;
    QList<Key> keys(const T &value) const;
    QList<T> values() const;
    QList<T> values(const Key &key) const;
    int count(const Key &key) const;

    class const_iterator;

    class iterator
    {
        QMapData::Node *i;
    public:
        typedef std::bidirectional_iterator_tag iterator_category;
        typedef ptrdiff_t difference_type;
        typedef T value_type;
        typedef T *pointer;
        typedef T &reference;

        inline operator QMapData::Node *() const { return i; }
        inline iterator() : i(0) { }
        inline iterator(QMapData::Node *node) : i(node) { }

        inline const Key &key() const { return concrete(i)->key; }
        inline T &value() const { return concrete(i)->value; }

        inline  T &data() const { return concrete(i)->value; }

        inline T &operator*() const { return concrete(i)->value; }
        inline T *operator->() const { return &concrete(i)->value; }
        inline bool operator==(const iterator &o) const { return i == o.i; }
        inline bool operator!=(const iterator &o) const { return i != o.i; }
        inline bool operator==(const const_iterator &o) const
            { return i == reinterpret_cast<const iterator &>(o).i; }
        inline bool operator!=(const const_iterator &o) const
            { return i != reinterpret_cast<const iterator &>(o).i; }

        inline iterator &operator++() {
            i = i->forward[0];
            return *this;
        }
        inline iterator operator++(int) {
            iterator r = *this;
            i = i->forward[0];
            return r;
        }
        inline iterator &operator--() {
            i = i->backward;
            return *this;
        }
        inline iterator operator--(int) {
            iterator r = *this;
            i = i->backward;
            return r;
        }
        inline iterator operator+(int j) const
        { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
        inline iterator operator-(int j) const { return operator+(-j); }
        inline iterator &operator+=(int j) { return *this = *this + j; }
        inline iterator &operator-=(int j) { return *this = *this - j; }
    };
    friend class iterator;

    class const_iterator
    {
        QMapData::Node *i;
    public:
        typedef std::bidirectional_iterator_tag iterator_category;
        typedef ptrdiff_t difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        inline operator QMapData::Node *() const { return i; }
        inline const_iterator() : i(0) { }
        inline const_iterator(QMapData::Node *node) : i(node) { }
        inline const_iterator(const iterator &o)
        { i = reinterpret_cast<const const_iterator &>(o).i; }

        inline const Key &key() const { return concrete(i)->key; }
        inline const T &value() const { return concrete(i)->value; }

        inline  const T &data() const { return concrete(i)->value; }

        inline const T &operator*() const { return concrete(i)->value; }
        inline const T *operator->() const { return &concrete(i)->value; }
        inline bool operator==(const const_iterator &o) const { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const { return i != o.i; }

        inline const_iterator &operator++() {
            i = i->forward[0];
            return *this;
        }
        inline const_iterator operator++(int) {
            const_iterator r = *this;
            i = i->forward[0];
            return r;
        }
        inline const_iterator &operator--() {
            i = i->backward;
            return *this;
        }
        inline const_iterator operator--(int) {
            const_iterator r = *this;
            i = i->backward;
            return r;
        }
        inline const_iterator operator+(int j) const
        { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
        inline const_iterator operator-(int j) const { return operator+(-j); }
        inline const_iterator &operator+=(int j) { return *this = *this + j; }
        inline const_iterator &operator-=(int j) { return *this = *this - j; }
    };
    friend class const_iterator;

    
    inline iterator begin() { detach(); return iterator(e->forward[0]); }
    inline const_iterator begin() const { return const_iterator(e->forward[0]); }
    inline const_iterator constBegin() const { return const_iterator(e->forward[0]); }
    inline iterator end() {
        detach();
        return iterator(e);
    }
    inline const_iterator end() const { return const_iterator(e); }
    inline const_iterator constEnd() const { return const_iterator(e); }
    iterator erase(iterator it);

    inline  iterator remove(iterator it) { return erase(it); }
    inline  void erase(const Key &key) { remove(key); }


    
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    inline int count() const { return d->size; }
    iterator find(const Key &key);
    const_iterator find(const Key &key) const;
    const_iterator constFind(const Key &key) const;
    iterator lowerBound(const Key &key);
    const_iterator lowerBound(const Key &key) const;
    iterator upperBound(const Key &key);
    const_iterator upperBound(const Key &key) const;
    iterator insert(const Key &key, const T &value);

     iterator insert(const Key &key, const T &value, bool overwrite);

    iterator insertMulti(const Key &key, const T &value);

    inline  iterator replace(const Key &key, const T &value) { return insert(key, value); }

    QMap<Key, T> &unite(const QMap<Key, T> &other);

    
    inline bool empty() const { return isEmpty(); }

private:
    void detach_helper();
    void freeData(QMapData *d);
    QMapData::Node *findNode(const Key &key) const;
    QMapData::Node *mutableFindNode(QMapData::Node *update[], const Key &key) const;
    QMapData::Node *node_create(QMapData *d, QMapData::Node *update[], const Key &key,
                                const T &value);






    template <class aKey, class aT>
    friend QDataStream &operator>> (QDataStream &in, QMap<aKey, aT> &map);



};

template <class Key, class T>
inline QMap<Key, T> &QMap<Key, T>::operator=(const QMap<Key, T> &other)
{
    if (d != other.d) {
        QMapData *x = other.d;
        x->ref.ref();
        x = qAtomicSetPtr(&d, x);
        if (!x->ref.deref())
            freeData(x);
        if (!d->sharable)
            detach_helper();
    }
    return *this;
}

template <class Key, class T>
inline void QMap<Key, T>::clear()
{
    *this = QMap<Key, T>();
}

template <class Key, class T>
inline typename QMapData::Node *
QMap<Key, T>::node_create(QMapData *adt, QMapData::Node *aupdate[], const Key &akey, const T &avalue)
{
    QMapData::Node *abstractNode = adt->node_create(aupdate, Payload);
    Node *concreteNode = concrete(abstractNode);
    new (&concreteNode->key) Key(akey);
    new (&concreteNode->value) T(avalue);
    return abstractNode;
}

template <class Key, class T>
inline QMapData::Node *QMap<Key, T>::findNode(const Key &akey) const
{
    QMapData::Node *cur = e;
    QMapData::Node *next = e;

    for (int i = d->topLevel; i >= 0; i--) {
        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
            cur = next;
    }

    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
        return next;
    } else {
        return e;
    }
}

template <class Key, class T>
inline const T QMap<Key, T>::value(const Key &akey) const
{
    QMapData::Node *node = findNode(akey);
    if (node == e) {
        return T();
    } else {
        return concrete(node)->value;
    }
}

template <class Key, class T>
inline const T QMap<Key, T>::value(const Key &akey, const T &adefaultValue) const
{
    QMapData::Node *node = findNode(akey);
    if (node == e) {
        return adefaultValue;
    } else {
        return concrete(node)->value;
    }
}

template <class Key, class T>
inline const T QMap<Key, T>::operator[](const Key &akey) const
{
    return value(akey);
}

template <class Key, class T>
inline T &QMap<Key, T>::operator[](const Key &akey)
{
    detach();

    QMapData::Node *update[QMapData::LastLevel + 1];
    QMapData::Node *node = mutableFindNode(update, akey);
    if (node == e)
        node = node_create(d, update, akey, T());
    return concrete(node)->value;
}

template <class Key, class T>
inline int QMap<Key, T>::count(const Key &akey) const
{
    int cnt = 0;
    QMapData::Node *node = findNode(akey);
    if (node != e) {
        do {
            ++cnt;
            node = node->forward[0];
        } while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key));
    }
    return cnt;
}

template <class Key, class T>
inline bool QMap<Key, T>::contains(const Key &akey) const
{
    return findNode(akey) != e;
}

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::insert(const Key &akey,
                                                                       const T &avalue)
{
    detach();

    QMapData::Node *update[QMapData::LastLevel + 1];
    QMapData::Node *node = mutableFindNode(update, akey);
    if (node == e) {
        node = node_create(d, update, akey, avalue);
    } else {
        concrete(node)->value = avalue;
    }
    return iterator(node);
}


template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::insert(const Key &akey,
                                                                       const T &avalue,
                                                                       bool aoverwrite)
{
    detach();

    QMapData::Node *update[QMapData::LastLevel + 1];
    QMapData::Node *node = mutableFindNode(update, akey);
    if (node == e) {
        node = node_create(d, update, akey, avalue);
    } else {
        if (aoverwrite)
            concrete(node)->value = avalue;
    }
    return iterator(node);
}


template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::insertMulti(const Key &akey,
                                                                            const T &avalue)
{
    detach();

    QMapData::Node *update[QMapData::LastLevel + 1];
    mutableFindNode(update, akey);
    return iterator(node_create(d, update, akey, avalue));
}

template <class Key, class T>
inline typename QMap<Key, T>::const_iterator QMap<Key, T>::find(const Key &akey) const
{
    return const_iterator(findNode(akey));
}

template <class Key, class T>
inline typename QMap<Key, T>::const_iterator QMap<Key, T>::constFind(const Key &akey) const
{
    return const_iterator(findNode(akey));
}

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::find(const Key &akey)
{
    detach();
    return iterator(findNode(akey));
}

template <class Key, class T>
inline QMap<Key, T> &QMap<Key, T>::unite(const QMap<Key, T> &other)
{
    QMap<Key, T> copy(other);
    const_iterator it = copy.constEnd();
    while (it != copy.constBegin()) {
        --it;
        insertMulti(it.key(), it.value());
    }
    return *this;
}

template <class Key, class T>
 void QMap<Key, T>::freeData(QMapData *x)
{
    if (QTypeInfo<Key>::isComplex || QTypeInfo<T>::isComplex) {
        QMapData::Node *y = reinterpret_cast<QMapData::Node *>(x);
        QMapData::Node *cur = y;
        QMapData::Node *next = cur->forward[0];
        while (next != y) {
            cur = next;
            next = cur->forward[0];
            Node *concreteNode = concrete(cur);
            concreteNode->key.~Key();
            concreteNode->value.~T();
        }
    }
    x->continueFreeData(Payload);
}

template <class Key, class T>
 int QMap<Key, T>::remove(const Key &akey)
{
    detach();

    QMapData::Node *update[QMapData::LastLevel + 1];
    QMapData::Node *cur = e;
    QMapData::Node *next = e;
    int oldSize = d->size;

    for (int i = d->topLevel; i >= 0; i--) {
        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
            cur = next;
        update[i] = cur;
    }

    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
        bool deleteNext = true;
        do {
            cur = next;
            next = cur->forward[0];
            deleteNext = (next != e && !qMapLessThanKey<Key>(concrete(cur)->key, concrete(next)->key));
            concrete(cur)->key.~Key();
            concrete(cur)->value.~T();
            d->node_delete(update, Payload, cur);
        } while (deleteNext);
    }
    return oldSize - d->size;
}

template <class Key, class T>
 T QMap<Key, T>::take(const Key &akey)
{
    detach();

    QMapData::Node *update[QMapData::LastLevel + 1];
    QMapData::Node *cur = e;
    QMapData::Node *next = e;

    for (int i = d->topLevel; i >= 0; i--) {
        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
            cur = next;
        update[i] = cur;
    }

    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
        T t = concrete(next)->value;
        concrete(next)->key.~Key();
        concrete(next)->value.~T();
        d->node_delete(update, Payload, next);
        return t;
    }
    return T();
}

template <class Key, class T>
 typename QMap<Key, T>::iterator QMap<Key, T>::erase(iterator it)
{
    QMapData::Node *update[QMapData::LastLevel + 1];
    QMapData::Node *cur = e;
    QMapData::Node *next = e;

    if (it == iterator(e))
        return it;

    for (int i = d->topLevel; i >= 0; i--) {
        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, it.key()))
            cur = next;
        update[i] = cur;
    }

    while (next != e) {
        cur = next;
        next = cur->forward[0];
        if (cur == it) {
            concrete(cur)->key.~Key();
            concrete(cur)->value.~T();
            d->node_delete(update, Payload, cur);
            return iterator(next);
        }

        for (int i = 0; i <= d->topLevel; ++i) {
            if (update[i]->forward[i] != cur)
                break;
            update[i] = cur;
        }
    }
    return end();
}

template <class Key, class T>
 void QMap<Key, T>::detach_helper()
{
    union { QMapData *d; QMapData::Node *e; } x;
    x.d = QMapData::createData();
    if (d->size) {
        x.d->insertInOrder = true;
        QMapData::Node *update[QMapData::LastLevel + 1];
        QMapData::Node *cur = e->forward[0];
        update[0] = x.e;
        while (cur != e) {
            Node *concreteNode = concrete(cur);
            node_create(x.d, update, concreteNode->key, concreteNode->value);
            cur = cur->forward[0];
        }
        x.d->insertInOrder = false;
    }
    x.d = qAtomicSetPtr(&d, x.d);
    if (!x.d->ref.deref())
        freeData(x.d);
}

template <class Key, class T>
 QMapData::Node *QMap<Key, T>::mutableFindNode(QMapData::Node *aupdate[],
                                                                   const Key &akey) const
{
    QMapData::Node *cur = e;
    QMapData::Node *next = e;

    for (int i = d->topLevel; i >= 0; i--) {
        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
            cur = next;
        aupdate[i] = cur;
    }
    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
        return next;
    } else {
        return e;
    }
}

template <class Key, class T>
 QList<Key> QMap<Key, T>::keys() const
{
    QList<Key> res;
    const_iterator i = begin();
    while (i != end()) {
        res.append(i.key());
        ++i;
    }
    return res;
}

template <class Key, class T>
 QList<Key> QMap<Key, T>::keys(const T &avalue) const
{
    QList<Key> res;
    const_iterator i = begin();
    while (i != end()) {
        if (i.value() == avalue)
            res.append(i.key());
        ++i;
    }
    return res;
}

template <class Key, class T>
 const Key QMap<Key, T>::key(const T &avalue) const
{
    const_iterator i = begin();
    while (i != end()) {
        if (i.value() == avalue)
            return i.key();
        ++i;
    }

    return Key();
}

template <class Key, class T>
 QList<T> QMap<Key, T>::values() const
{
    QList<T> res;
    const_iterator i = begin();
    while (i != end()) {
        res.append(i.value());
        ++i;
    }
    return res;
}

template <class Key, class T>
 QList<T> QMap<Key, T>::values(const Key &akey) const
{
    QList<T> res;
    QMapData::Node *node = findNode(akey);
    if (node != e) {
        do {
            res.append(concrete(node)->value);
            node = node->forward[0];
        } while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key));
    }
    return res;
}

template <class Key, class T>
inline typename QMap<Key, T>::const_iterator
QMap<Key, T>::lowerBound(const Key &akey) const
{
    QMapData::Node *update[QMapData::LastLevel + 1];
    mutableFindNode(update, akey);
    return const_iterator(update[0]->forward[0]);
}

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::lowerBound(const Key &akey)
{
    detach();
    return static_cast<QMapData::Node *>(const_cast<const QMap *>(this)->lowerBound(akey));
}

template <class Key, class T>
inline typename QMap<Key, T>::const_iterator
QMap<Key, T>::upperBound(const Key &akey) const
{
    QMapData::Node *update[QMapData::LastLevel + 1];
    mutableFindNode(update, akey);
    QMapData::Node *node = update[0]->forward[0];
    while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key))
        node = node->forward[0];
    return const_iterator(node);
}

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::upperBound(const Key &akey)
{
    detach();
    return static_cast<QMapData::Node *>(const_cast<const QMap *>(this)->upperBound(akey));
}

template <class Key, class T>
 bool QMap<Key, T>::operator==(const QMap<Key, T> &other) const
{
    if (size() != other.size())
        return false;
    if (d == other.d)
        return true;

    const_iterator it1 = begin();
    const_iterator it2 = other.begin();

    while (it1 != end()) {
        if (!(it1.value() == it2.value()) || qMapLessThanKey(it1.key(), it2.key()) || qMapLessThanKey(it2.key(), it1.key()))
            return false;
        ++it2;
        ++it1;
    }
    return true;
}


template <class Key, class T>
 QMap<Key, T>::QMap(const std::map<Key, T> &other)
{
    d = QMapData::createData();
    d->insertInOrder = true;
    typename std::map<Key,T>::const_iterator it = other.end();
    while (it != other.begin()) {
        --it;
        insert((*it).first, (*it).second);
    }
    d->insertInOrder = false;
}

template <class Key, class T>
  std::map<Key, T> QMap<Key, T>::toStdMap() const
{
    std::map<Key, T> map;
    const_iterator it = end();
    while (it != begin()) {
        --it;
        map.insert(std::pair<Key, T>(it.key(), it.value()));
    }
    return map;
}



template <class Key, class T>
class QMultiMap : public QMap<Key, T>
{
public:
    QMultiMap() {}
    QMultiMap(const QMap<Key, T> &other) : QMap<Key, T>(other) {}

    inline typename QMap<Key, T>::iterator replace(const Key &key, const T &value);
    inline typename QMap<Key, T>::iterator insert(const Key &key, const T &value);

    inline QMultiMap &operator+=(const QMultiMap &other)
    { unite(other); return *this; }
    inline QMultiMap operator+(const QMultiMap &other) const
    { QMultiMap result = *this; result += other; return result; }

private:
    T &operator[](const Key &key);
    const T operator[](const Key &key) const;
};

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMultiMap<Key, T>::replace(const Key &akey, const T &avalue)
{ return QMap<Key, T>::insert(akey, avalue); }

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMultiMap<Key, T>::insert(const Key &akey, const T &avalue)
{ return QMap<Key, T>::insertMulti(akey, avalue); }


template <class Key, class T> class QMapIterator { typedef typename QMap<Key,T> ::const_iterator const_iterator; typedef const_iterator Item; QMap<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c . constEnd(); } public: inline QMapIterator(const QMap<Key,T> &container) : c(container), i(c . constBegin()), n(c . constEnd()) {} inline QMapIterator &operator=(const QMap<Key,T> &container) { c = container; i = c . constBegin(); n = c . constEnd(); return *this; } inline void toFront() { i = c . constBegin(); n = c . constEnd(); } inline void toBack() { i = c . constEnd(); n = c . constEnd(); } inline bool hasNext() const { return i != c . constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c . constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qmap.h",852);} while (0); return *n; } inline const Key &key() const { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qmap.h",852);} while (0); return n . key(); } inline bool findNext(const T &t) { while ((n = i) != c . constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c . constBegin()) if (*(n = --i) == t) return true; n = c . constEnd(); return false; } };
template <class Key, class T> class QMutableMapIterator { typedef typename QMap<Key,T> ::iterator iterator; typedef iterator Item; QMap<Key,T> *c; iterator i, n; inline bool item_exists() const { return n != c->constEnd(); } public: inline QMutableMapIterator(QMap<Key,T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableMapIterator() { c->setSharable(true); } inline QMutableMapIterator &operator=(QMap<Key,T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return i != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (n != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (n != c->constEnd()) *n = t; } inline T &value() { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qmap.h",853);} while (0); return *n; } inline const T &value() const { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qmap.h",853);} while (0); return *n; } inline const Key &key() const { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qmap.h",853);} while (0); return n . key(); } inline bool findNext(const T &t) { while ((n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } };



#line 2 "../../include/QtCore/qmap.h"
#line 29 "../../include/QtCore/../../src/corelib/io/qdebug.h"
#line 1 "../../include/QtCore/qpair.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qpair.h"



















 




#line 1 "../../include/QtCore/qdatastream.h"
#line 1 "../../include/QtCore/../../src/corelib/io/qdatastream.h"



















 




#line 1 "../../include/QtCore/qiodevice.h"
#line 1 "../../include/QtCore/../../src/corelib/io/qiodevice.h"



















 




#line 1 "../../include/QtCore/qobject.h"
#line 1 "../../include/QtCore/../../src/corelib/kernel/qobject.h"



















 






#line 1 "../../include/QtCore/qobjectdefs.h"
#line 1 "../../include/QtCore/../../src/corelib/kernel/qobjectdefs.h"



















 




#line 1 "../../include/QtCore/qnamespace.h"
#line 1 "../../include/QtCore/../../src/corelib/global/qnamespace.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtCore/../../src/corelib/global/qnamespace.h"



typedef QtValidLicenseForCoreModule QtCoreModule;


namespace



Qt {
#line 49 "../../include/QtCore/../../src/corelib/global/qnamespace.h"
    enum GlobalColor {
        color0,
        color1,
        black,
        white,
        darkGray,
        gray,
        lightGray,
        red,
        green,
        blue,
        cyan,
        magenta,
        yellow,
        darkRed,
        darkGreen,
        darkBlue,
        darkCyan,
        darkMagenta,
        darkYellow,
        transparent
    };

    enum KeyboardModifier {
        NoModifier           = 0x00000000,
        ShiftModifier        = 0x02000000,
        ControlModifier      = 0x04000000,
        AltModifier          = 0x08000000,
        MetaModifier         = 0x10000000,
        KeypadModifier       = 0x20000000,
        
        KeyboardModifierMask = 0xfe000000
    };
    typedef QFlags<KeyboardModifier> KeyboardModifiers;

    
    enum Modifier {
        META          = Qt::MetaModifier,
        SHIFT         = Qt::ShiftModifier,
        CTRL          = Qt::ControlModifier,
        ALT           = Qt::AltModifier,
        MODIFIER_MASK = KeyboardModifierMask,
        UNICODE_ACCEL = 0x00000000
    };

    enum MouseButton {
        NoButton         = 0x00000000,
        LeftButton       = 0x00000001,
        RightButton      = 0x00000002,
        MidButton        = 0x00000004,
        XButton1         = 0x00000008,
        XButton2         = 0x00000010,
        MouseButtonMask  = 0x000000ff
    };
    typedef QFlags<MouseButton> MouseButtons;


    enum ButtonState_enum {
        ShiftButton     = Qt::ShiftModifier,
        ControlButton   = Qt::ControlModifier,
        AltButton       = Qt::AltModifier,
        MetaButton      = Qt::MetaModifier,
        Keypad          = Qt::KeypadModifier,
        KeyButtonMask   = Qt::KeyboardModifierMask
    };
    typedef int ButtonState;


    enum Orientation {
        Horizontal = 0x1,
        Vertical = 0x2
    };

    typedef QFlags<Orientation> Orientations;

    enum FocusPolicy {
        NoFocus = 0,
        TabFocus = 0x1,
        ClickFocus = 0x2,
        StrongFocus = TabFocus | ClickFocus | 0x8,
        WheelFocus = StrongFocus | 0x4
    };

    enum SortOrder {
        AscendingOrder,
        DescendingOrder

        ,Ascending = AscendingOrder,
        Descending = DescendingOrder

    };

    
    
    

    enum AlignmentFlag {
        AlignLeft = 0x0001,
        AlignLeading = AlignLeft,
        AlignRight = 0x0002,
        AlignTrailing = AlignRight,
        AlignHCenter = 0x0004,
        AlignJustify = 0x0008,
        AlignAbsolute = 0x0010,
        AlignHorizontal_Mask = AlignLeft | AlignRight | AlignHCenter | AlignJustify | AlignAbsolute,

        AlignTop = 0x0020,
        AlignBottom = 0x0040,
        AlignVCenter = 0x0080,
        AlignVertical_Mask = AlignTop | AlignBottom | AlignVCenter,

        AlignCenter = AlignVCenter | AlignHCenter

        , AlignAuto = AlignLeft

    };

    typedef QFlags<AlignmentFlag> Alignment;

    enum TextFlag {
        TextSingleLine = 0x0100,
        TextDontClip = 0x0200,
        TextExpandTabs = 0x0400,
        TextShowMnemonic = 0x0800,
        TextWordWrap = 0x1000,
        TextWrapAnywhere = 0x2000,
        TextDontPrint = 0x4000,
        TextIncludeTrailingSpaces = 0x08000000,
        TextHideMnemonic = 0x8000


        ,SingleLine = TextSingleLine,
        DontClip = TextDontClip,
        ExpandTabs = TextExpandTabs,
        ShowPrefix = TextShowMnemonic,
        WordBreak = TextWordWrap,
        BreakAnywhere = TextWrapAnywhere,
        DontPrint = TextDontPrint,
        IncludeTrailingSpaces = TextIncludeTrailingSpaces,
        NoAccel = TextHideMnemonic

    };

    typedef TextFlag TextFlags;


    enum TextElideMode {
        ElideLeft,
        ElideRight,
        ElideMiddle
    };

    enum WindowType {
        Widget = 0x00000000,
        Window = 0x00000001,
        Dialog = 0x00000002 | Window,
        Sheet = 0x00000004 | Window,
        Drawer = 0x00000006 | Window,
        Popup = 0x00000008 | Window,
        Tool = 0x0000000a | Window,
        ToolTip = 0x0000000c | Window,
        SplashScreen = 0x0000000e | Window,
        Desktop = 0x00000010 | Window,
        SubWindow =  0x00000012,

        WindowType_Mask = 0x000000ff,
        MSWindowsFixedSizeDialogHint = 0x00000100,
	MSWindowsOwnDC = 0x00000200,
        X11BypassWindowManagerHint = 0x00000400,
        FramelessWindowHint = 0x00000800,
        WindowTitleHint = 0x00001000,
        WindowSystemMenuHint = 0x00002000,
        WindowMinimizeButtonHint = 0x00004000,
        WindowMaximizeButtonHint = 0x00008000,
        WindowMinMaxButtonsHint = WindowMinimizeButtonHint | WindowMaximizeButtonHint,
        WindowContextHelpButtonHint = 0x00010000,
        WindowShadeButtonHint = 0x00020000,
        WindowStaysOnTopHint = 0x00040000


        ,
        WMouseNoMask = 0x00080000,
        WDestructiveClose = 0x00100000,
        WStaticContents = 0x00200000,
        WGroupLeader = 0x00400000,
        WShowModal = 0x00800000,
        WNoMousePropagation = 0x01000000,

        WType_TopLevel = Window,
        WType_Dialog = Dialog,
        WType_Popup = Popup,
        WType_Desktop = Desktop,
        WType_Mask = WindowType_Mask,

        WStyle_Customize = 0,
        WStyle_NormalBorder = 0,
        WStyle_DialogBorder = MSWindowsFixedSizeDialogHint,
        WStyle_NoBorder = FramelessWindowHint,
        WStyle_Title = WindowTitleHint,
        WStyle_SysMenu = WindowSystemMenuHint,
        WStyle_Minimize = WindowMinimizeButtonHint,
        WStyle_Maximize = WindowMaximizeButtonHint,
        WStyle_MinMax = WStyle_Minimize | WStyle_Maximize,
        WStyle_Tool = Tool,
        WStyle_StaysOnTop = WindowStaysOnTopHint,
        WStyle_ContextHelp = WindowContextHelpButtonHint,

        
        WPaintDesktop = 0,
        WPaintClever = 0,

        WX11BypassWM            = X11BypassWindowManagerHint,
        WWinOwnDC               = MSWindowsOwnDC,
        WMacSheet               = Sheet,
        WMacDrawer              = Drawer,

        WStyle_Splash           = SplashScreen,

        WNoAutoErase           = 0,
        WRepaintNoErase        = 0,
        WNorthWestGravity      = WStaticContents,
        WType_Modal            = Dialog | WShowModal,
        WStyle_Dialog          = Dialog,
        WStyle_NoBorderEx      = FramelessWindowHint,
        WResizeNoErase = 0,
        WMacNoSheet = 0


    };

    typedef QFlags<WindowType> WindowFlags;

    enum WindowState {
        WindowNoState    = 0x00000000,
        WindowMinimized  = 0x00000001,
        WindowMaximized  = 0x00000002,
        WindowFullScreen = 0x00000004,
        WindowActive     = 0x00000008
    };

    typedef QFlags<WindowState> WindowStates;

    enum WidgetAttribute {
        WA_Disabled = 0,
        WA_UnderMouse = 1,
        WA_MouseTracking = 2,
        WA_ContentsPropagated = 3, 
        WA_OpaquePaintEvent = 4,
        WA_NoBackground = WA_OpaquePaintEvent, 
        WA_StaticContents = 5,
        WA_LaidOut = 7,
        WA_PaintOnScreen = 8,
        WA_NoSystemBackground = 9,
        WA_UpdatesDisabled = 10,
        WA_Mapped = 11,
        WA_MacNoClickThrough = 12, 
        WA_PaintOutsidePaintEvent = 13,
        WA_InputMethodEnabled = 14,
        WA_WState_Visible = 15,
        WA_WState_Hidden = 16,

        WA_ForceDisabled = 32,
        WA_KeyCompression = 33,
        WA_PendingMoveEvent = 34,
        WA_PendingResizeEvent = 35,
        WA_SetPalette = 36,
        WA_SetFont = 37,
        WA_SetCursor = 38,
        WA_NoChildEventsFromChildren = 39,
        WA_WindowModified = 41,
        WA_Resized = 42,
        WA_Moved = 43,
        WA_PendingUpdate = 44,
        WA_InvalidSize = 45,
        WA_MacMetalStyle = 46, 
        WA_CustomWhatsThis = 47,
        WA_LayoutOnEntireRect = 48,
        WA_OutsideWSRange = 49,
        WA_GrabbedShortcut = 50,
        WA_TransparentForMouseEvents = 51,
        WA_PaintUnclipped = 52,
        WA_SetWindowIcon = 53,
        WA_NoMouseReplay = 54,
        WA_DeleteOnClose = 55,
        WA_RightToLeft = 56,
        WA_SetLayoutDirection = 57,
        WA_NoChildEventsForParent = 58,
        WA_ForceUpdatesDisabled = 59,

        WA_WState_Created = 60,
        WA_WState_CompressKeys = 61,
        WA_WState_InPaintEvent = 62,
        WA_WState_Reparented = 63,
        WA_WState_ConfigPending = 64,
        WA_WState_Polished = 66,
        WA_WState_DND = 67, 
        WA_WState_OwnSizePolicy = 68,
        WA_WState_ExplicitShowHide = 69,

        WA_ShowModal = 70, 
        WA_MouseNoMask = 71,
        WA_GroupLeader = 72, 
        WA_NoMousePropagation = 73, 
        WA_Hover = 74,
        WA_InputMethodTransparent = 75, 
        WA_QuitOnClose = 76,

        WA_KeyboardFocusChange = 77,

        WA_AcceptDrops = 78,
        WA_DropSiteRegistered = 79, 
        WA_ForceAcceptDrops = WA_DropSiteRegistered, 

        WA_WindowPropagation = 80,

        WA_NoX11EventCompression = 81,
        WA_TintedBackground = 82,
        WA_X11OpenGLOverlay = 83,

        
        WA_AttributeCount
    };

    
    

    enum ImageConversionFlag {
        ColorMode_Mask          = 0x00000003,
        AutoColor               = 0x00000000,
        ColorOnly               = 0x00000003,
        MonoOnly                = 0x00000002,
        

        AlphaDither_Mask        = 0x0000000c,
        ThresholdAlphaDither    = 0x00000000,
        OrderedAlphaDither      = 0x00000004,
        DiffuseAlphaDither      = 0x00000008,
        NoAlpha                 = 0x0000000c, 

        Dither_Mask             = 0x00000030,
        DiffuseDither           = 0x00000000,
        OrderedDither           = 0x00000010,
        ThresholdDither         = 0x00000020,
        

        DitherMode_Mask         = 0x000000c0,
        AutoDither              = 0x00000000,
        PreferDither            = 0x00000040,
        AvoidDither             = 0x00000080
    };
    typedef QFlags<ImageConversionFlag> ImageConversionFlags;

    enum BGMode {
        TransparentMode,
        OpaqueMode
    };


    enum PaintUnit {                                
        PixelUnit,
        LoMetricUnit, 
        HiMetricUnit, 
        LoEnglishUnit, 
        HiEnglishUnit, 
        TwipsUnit 
    };

    enum GUIStyle {
        MacStyle,
        WindowsStyle,
        Win3Style,
        PMStyle,
        MotifStyle
    };


    enum Key {
        Key_Escape = 0x01000000,                
        Key_Tab = 0x01000001,
        Key_Backtab = 0x01000002,

        Key_BackTab = Key_Backtab,

        Key_Backspace = 0x01000003,

        Key_BackSpace = Key_Backspace,

        Key_Return = 0x01000004,
        Key_Enter = 0x01000005,
        Key_Insert = 0x01000006,
        Key_Delete = 0x01000007,
        Key_Pause = 0x01000008,
        Key_Print = 0x01000009,
        Key_SysReq = 0x0100000a,
        Key_Clear = 0x0100000b,
        Key_Home = 0x01000010,                
        Key_End = 0x01000011,
        Key_Left = 0x01000012,
        Key_Up = 0x01000013,
        Key_Right = 0x01000014,
        Key_Down = 0x01000015,
        Key_PageUp = 0x01000016,

        Key_Prior = Key_PageUp,

        Key_PageDown = 0x01000017,

        Key_Next = Key_PageDown,

        Key_Shift = 0x01000020,                
        Key_Control = 0x01000021,
        Key_Meta = 0x01000022,
        Key_Alt = 0x01000023,
        Key_CapsLock = 0x01000024,
        Key_NumLock = 0x01000025,
        Key_ScrollLock = 0x01000026,
        Key_F1 = 0x01000030,                
        Key_F2 = 0x01000031,
        Key_F3 = 0x01000032,
        Key_F4 = 0x01000033,
        Key_F5 = 0x01000034,
        Key_F6 = 0x01000035,
        Key_F7 = 0x01000036,
        Key_F8 = 0x01000037,
        Key_F9 = 0x01000038,
        Key_F10 = 0x01000039,
        Key_F11 = 0x0100003a,
        Key_F12 = 0x0100003b,
        Key_F13 = 0x0100003c,
        Key_F14 = 0x0100003d,
        Key_F15 = 0x0100003e,
        Key_F16 = 0x0100003f,
        Key_F17 = 0x01000040,
        Key_F18 = 0x01000041,
        Key_F19 = 0x01000042,
        Key_F20 = 0x01000043,
        Key_F21 = 0x01000044,
        Key_F22 = 0x01000045,
        Key_F23 = 0x01000046,
        Key_F24 = 0x01000047,
        Key_F25 = 0x01000048,                
        Key_F26 = 0x01000049,
        Key_F27 = 0x0100004a,
        Key_F28 = 0x0100004b,
        Key_F29 = 0x0100004c,
        Key_F30 = 0x0100004d,
        Key_F31 = 0x0100004e,
        Key_F32 = 0x0100004f,
        Key_F33 = 0x01000050,
        Key_F34 = 0x01000051,
        Key_F35 = 0x01000052,
        Key_Super_L = 0x01000053,                 
        Key_Super_R = 0x01000054,
        Key_Menu = 0x01000055,
        Key_Hyper_L = 0x01000056,
        Key_Hyper_R = 0x01000057,
        Key_Help = 0x01000058,
        Key_Direction_L = 0x01000059,
        Key_Direction_R = 0x01000060,
        Key_Space = 0x20,                
        Key_Any = Key_Space,
        Key_Exclam = 0x21,
        Key_QuoteDbl = 0x22,
        Key_NumberSign = 0x23,
        Key_Dollar = 0x24,
        Key_Percent = 0x25,
        Key_Ampersand = 0x26,
        Key_Apostrophe = 0x27,
        Key_ParenLeft = 0x28,
        Key_ParenRight = 0x29,
        Key_Asterisk = 0x2a,
        Key_Plus = 0x2b,
        Key_Comma = 0x2c,
        Key_Minus = 0x2d,
        Key_Period = 0x2e,
        Key_Slash = 0x2f,
        Key_0 = 0x30,
        Key_1 = 0x31,
        Key_2 = 0x32,
        Key_3 = 0x33,
        Key_4 = 0x34,
        Key_5 = 0x35,
        Key_6 = 0x36,
        Key_7 = 0x37,
        Key_8 = 0x38,
        Key_9 = 0x39,
        Key_Colon = 0x3a,
        Key_Semicolon = 0x3b,
        Key_Less = 0x3c,
        Key_Equal = 0x3d,
        Key_Greater = 0x3e,
        Key_Question = 0x3f,
        Key_At = 0x40,
        Key_A = 0x41,
        Key_B = 0x42,
        Key_C = 0x43,
        Key_D = 0x44,
        Key_E = 0x45,
        Key_F = 0x46,
        Key_G = 0x47,
        Key_H = 0x48,
        Key_I = 0x49,
        Key_J = 0x4a,
        Key_K = 0x4b,
        Key_L = 0x4c,
        Key_M = 0x4d,
        Key_N = 0x4e,
        Key_O = 0x4f,
        Key_P = 0x50,
        Key_Q = 0x51,
        Key_R = 0x52,
        Key_S = 0x53,
        Key_T = 0x54,
        Key_U = 0x55,
        Key_V = 0x56,
        Key_W = 0x57,
        Key_X = 0x58,
        Key_Y = 0x59,
        Key_Z = 0x5a,
        Key_BracketLeft = 0x5b,
        Key_Backslash = 0x5c,
        Key_BracketRight = 0x5d,
        Key_AsciiCircum = 0x5e,
        Key_Underscore = 0x5f,
        Key_QuoteLeft = 0x60,
        Key_BraceLeft = 0x7b,
        Key_Bar = 0x7c,
        Key_BraceRight = 0x7d,
        Key_AsciiTilde = 0x7e,

        Key_nobreakspace = 0x0a0,
        Key_exclamdown = 0x0a1,
        Key_cent = 0x0a2,
        Key_sterling = 0x0a3,
        Key_currency = 0x0a4,
        Key_yen = 0x0a5,
        Key_brokenbar = 0x0a6,
        Key_section = 0x0a7,
        Key_diaeresis = 0x0a8,
        Key_copyright = 0x0a9,
        Key_ordfeminine = 0x0aa,
        Key_guillemotleft = 0x0ab,        
        Key_notsign = 0x0ac,
        Key_hyphen = 0x0ad,
        Key_registered = 0x0ae,
        Key_macron = 0x0af,
        Key_degree = 0x0b0,
        Key_plusminus = 0x0b1,
        Key_twosuperior = 0x0b2,
        Key_threesuperior = 0x0b3,
        Key_acute = 0x0b4,
        Key_mu = 0x0b5,
        Key_paragraph = 0x0b6,
        Key_periodcentered = 0x0b7,
        Key_cedilla = 0x0b8,
        Key_onesuperior = 0x0b9,
        Key_masculine = 0x0ba,
        Key_guillemotright = 0x0bb,        
        Key_onequarter = 0x0bc,
        Key_onehalf = 0x0bd,
        Key_threequarters = 0x0be,
        Key_questiondown = 0x0bf,
        Key_Agrave = 0x0c0,
        Key_Aacute = 0x0c1,
        Key_Acircumflex = 0x0c2,
        Key_Atilde = 0x0c3,
        Key_Adiaeresis = 0x0c4,
        Key_Aring = 0x0c5,
        Key_AE = 0x0c6,
        Key_Ccedilla = 0x0c7,
        Key_Egrave = 0x0c8,
        Key_Eacute = 0x0c9,
        Key_Ecircumflex = 0x0ca,
        Key_Ediaeresis = 0x0cb,
        Key_Igrave = 0x0cc,
        Key_Iacute = 0x0cd,
        Key_Icircumflex = 0x0ce,
        Key_Idiaeresis = 0x0cf,
        Key_ETH = 0x0d0,
        Key_Ntilde = 0x0d1,
        Key_Ograve = 0x0d2,
        Key_Oacute = 0x0d3,
        Key_Ocircumflex = 0x0d4,
        Key_Otilde = 0x0d5,
        Key_Odiaeresis = 0x0d6,
        Key_multiply = 0x0d7,
        Key_Ooblique = 0x0d8,
        Key_Ugrave = 0x0d9,
        Key_Uacute = 0x0da,
        Key_Ucircumflex = 0x0db,
        Key_Udiaeresis = 0x0dc,
        Key_Yacute = 0x0dd,
        Key_THORN = 0x0de,
        Key_ssharp = 0x0df,

        Key_agrave = Key_Agrave,
        Key_aacute = Key_Aacute,
        Key_acircumflex = Key_Acircumflex,
        Key_atilde = Key_Atilde,
        Key_adiaeresis = Key_Adiaeresis,
        Key_aring = Key_Aring,
        Key_ae = Key_AE,
        Key_ccedilla = Key_Ccedilla,
        Key_egrave = Key_Egrave,
        Key_eacute = Key_Eacute,
        Key_ecircumflex = Key_Ecircumflex,
        Key_ediaeresis = Key_Ediaeresis,
        Key_igrave = Key_Igrave,
        Key_iacute = Key_Iacute,
        Key_icircumflex = Key_Icircumflex,
        Key_idiaeresis = Key_Idiaeresis,
        Key_eth = Key_ETH,
        Key_ntilde = Key_Ntilde,
        Key_ograve = Key_Ograve,
        Key_oacute = Key_Oacute,
        Key_ocircumflex = Key_Ocircumflex,
        Key_otilde = Key_Otilde,
        Key_odiaeresis = Key_Odiaeresis,

        Key_division = 0x0f7,

        Key_oslash = Key_Ooblique,
        Key_ugrave = Key_Ugrave,
        Key_uacute = Key_Uacute,
        Key_ucircumflex = Key_Ucircumflex,
        Key_udiaeresis = Key_Udiaeresis,
        Key_yacute = Key_Yacute,
        Key_thorn = Key_THORN,

        Key_ydiaeresis = 0x0ff,

	
	
	

	
        Key_AltGr               = 0x01001103,
	Key_Multi_key           = 0x01001120,  
	Key_Codeinput           = 0x01001137,
	Key_SingleCandidate     = 0x0100113c,
	Key_MultipleCandidate   = 0x0100113d,
	Key_PreviousCandidate   = 0x0100113e,

	
	Key_Mode_switch         = 0x0100117e,  
	

	
	Key_Kanji               = 0x01001121,  
	Key_Muhenkan            = 0x01001122,  
	
	Key_Henkan              = 0x01001123,  
	Key_Romaji              = 0x01001124,  
	Key_Hiragana            = 0x01001125,  
	Key_Katakana            = 0x01001126,  
	Key_Hiragana_Katakana   = 0x01001127,  
	Key_Zenkaku             = 0x01001128,  
	Key_Hankaku             = 0x01001129,  
	Key_Zenkaku_Hankaku     = 0x0100112a,  
	Key_Touroku             = 0x0100112b,  
	Key_Massyo              = 0x0100112c,  
	Key_Kana_Lock           = 0x0100112d,  
	Key_Kana_Shift          = 0x0100112e,  
	Key_Eisu_Shift          = 0x0100112f,  
	Key_Eisu_toggle         = 0x01001130,  
	
	
	

	
	
	
	

	Key_Hangul              = 0x01001131,  
	Key_Hangul_Start        = 0x01001132,  
	Key_Hangul_End          = 0x01001133,  
	Key_Hangul_Hanja        = 0x01001134,  
	Key_Hangul_Jamo         = 0x01001135,  
	Key_Hangul_Romaja       = 0x01001136,  
	
	Key_Hangul_Jeonja       = 0x01001138,  
	Key_Hangul_Banja        = 0x01001139,  
	Key_Hangul_PreHanja     = 0x0100113a,  
	Key_Hangul_PostHanja    = 0x0100113b,  
	
	
	
	Key_Hangul_Special      = 0x0100113f,  
	

        
        Key_Dead_Grave          = 0x01001250,
        Key_Dead_Acute          = 0x01001251,
        Key_Dead_Circumflex     = 0x01001252,
        Key_Dead_Tilde          = 0x01001253,
        Key_Dead_Macron         = 0x01001254,
        Key_Dead_Breve          = 0x01001255,
        Key_Dead_Abovedot       = 0x01001256,
        Key_Dead_Diaeresis      = 0x01001257,
        Key_Dead_Abovering      = 0x01001258,
        Key_Dead_Doubleacute    = 0x01001259,
        Key_Dead_Caron          = 0x0100125a,
        Key_Dead_Cedilla        = 0x0100125b,
        Key_Dead_Ogonek         = 0x0100125c,
        Key_Dead_Iota           = 0x0100125d,
        Key_Dead_Voiced_Sound   = 0x0100125e,
        Key_Dead_Semivoiced_Sound = 0x0100125f,
        Key_Dead_Belowdot       = 0x01001260,
        Key_Dead_Hook           = 0x01001261,
        Key_Dead_Horn           = 0x01001262,

        

        Key_Back  = 0x01000061,
        Key_Forward  = 0x01000062,
        Key_Stop  = 0x01000063,
        Key_Refresh  = 0x01000064,

        Key_VolumeDown = 0x01000070,
        Key_VolumeMute  = 0x01000071,
        Key_VolumeUp = 0x01000072,
        Key_BassBoost = 0x01000073,
        Key_BassUp = 0x01000074,
        Key_BassDown = 0x01000075,
        Key_TrebleUp = 0x01000076,
        Key_TrebleDown = 0x01000077,

        Key_MediaPlay  = 0x01000080,
        Key_MediaStop  = 0x01000081,
        Key_MediaPrevious  = 0x01000082,

        Key_MediaPrev  = Key_MediaPrevious,

        Key_MediaNext  = 0x01000083,
        Key_MediaRecord = 0x01000084,

        Key_HomePage  = 0x01000090,
        Key_Favorites  = 0x01000091,
        Key_Search  = 0x01000092,
        Key_Standby = 0x01000093,
        Key_OpenUrl = 0x01000094,

        Key_LaunchMail  = 0x010000a0,
        Key_LaunchMedia = 0x010000a1,
        Key_Launch0  = 0x010000a2,
        Key_Launch1  = 0x010000a3,
        Key_Launch2  = 0x010000a4,
        Key_Launch3  = 0x010000a5,
        Key_Launch4  = 0x010000a6,
        Key_Launch5  = 0x010000a7,
        Key_Launch6  = 0x010000a8,
        Key_Launch7  = 0x010000a9,
        Key_Launch8  = 0x010000aa,
        Key_Launch9  = 0x010000ab,
        Key_LaunchA  = 0x010000ac,
        Key_LaunchB  = 0x010000ad,
        Key_LaunchC  = 0x010000ae,
        Key_LaunchD  = 0x010000af,
        Key_LaunchE  = 0x010000b0,
        Key_LaunchF  = 0x010000b1,

        Key_MediaLast = 0x0100ffff,

        
        Key_Select = 0x01010000,
        Key_Yes = 0x01010001,
        Key_No = 0x01010002,

        
        Key_Context1 = 0x01100000,
        Key_Context2 = 0x01100001,
        Key_Context3 = 0x01100002,
        Key_Context4 = 0x01100003,
        Key_Call = 0x01100004,
        Key_Hangup = 0x01100005,
        Key_Flip = 0x01100006,

        Key_unknown = 0x01ffffff
    };

    enum ArrowType {
        NoArrow,
        UpArrow,
        DownArrow,
        LeftArrow,
        RightArrow
    };

    enum PenStyle { 
        NoPen,
        SolidLine,
        DashLine,
        DotLine,
        DashDotLine,
        DashDotDotLine,
        CustomDashLine,
        MPenStyle = 0x0f
    };

    enum PenCapStyle { 
        FlatCap = 0x00,
        SquareCap = 0x10,
        RoundCap = 0x20,
        MPenCapStyle = 0x30
    };

    enum PenJoinStyle { 
        MiterJoin = 0x00,
        BevelJoin = 0x40,
        RoundJoin = 0x80,
        MPenJoinStyle = 0xc0
    };

    enum BrushStyle { 
        NoBrush,
        SolidPattern,
        Dense1Pattern,
        Dense2Pattern,
        Dense3Pattern,
        Dense4Pattern,
        Dense5Pattern,
        Dense6Pattern,
        Dense7Pattern,
        HorPattern,
        VerPattern,
        CrossPattern,
        BDiagPattern,
        FDiagPattern,
        DiagCrossPattern,
        LinearGradientPattern,
        RadialGradientPattern,
        ConicalGradientPattern,
        TexturePattern = 24

        , CustomPattern = TexturePattern

    };

#line 917 "../../include/QtCore/../../src/corelib/global/qnamespace.h"

#line 945 "../../include/QtCore/../../src/corelib/global/qnamespace.h"

    enum UIEffect {
        UI_General,
        UI_AnimateMenu,
        UI_FadeMenu,
        UI_AnimateCombo,
        UI_AnimateTooltip,
        UI_FadeTooltip,
        UI_AnimateToolBox
    };

    enum CursorShape {
        ArrowCursor,
        UpArrowCursor,
        CrossCursor,
        WaitCursor,
        IBeamCursor,
        SizeVerCursor,
        SizeHorCursor,
        SizeBDiagCursor,
        SizeFDiagCursor,
        SizeAllCursor,
        BlankCursor,
        SplitVCursor,
        SplitHCursor,
        PointingHandCursor,
        ForbiddenCursor,
        WhatsThisCursor,
        BusyCursor,
        LastCursor = BusyCursor,
        BitmapCursor = 24,
        CustomCursor = 25


        ,
        arrowCursor = ArrowCursor,
        upArrowCursor = UpArrowCursor,
        crossCursor = CrossCursor,
        waitCursor = WaitCursor,
        ibeamCursor = IBeamCursor,
        sizeVerCursor = SizeVerCursor,
        sizeHorCursor = SizeHorCursor,
        sizeBDiagCursor = SizeBDiagCursor,
        sizeFDiagCursor = SizeFDiagCursor,
        sizeAllCursor = SizeAllCursor,
        blankCursor = BlankCursor,
        splitVCursor = SplitVCursor,
        splitHCursor = SplitHCursor,
        pointingHandCursor = PointingHandCursor,
        forbiddenCursor = ForbiddenCursor,
        whatsThisCursor = WhatsThisCursor

    };

    enum TextFormat {
        PlainText,
        RichText,
        AutoText,
        LogText
    };

    enum AspectRatioMode {
        IgnoreAspectRatio,
        KeepAspectRatio,
        KeepAspectRatioByExpanding

        , ScaleFree = IgnoreAspectRatio,
        ScaleMin = KeepAspectRatio,
        ScaleMax = KeepAspectRatioByExpanding

    };

    typedef AspectRatioMode ScaleMode;


    enum AnchorAttribute {
        AnchorName,
        AnchorHref
    };

    enum DockWidgetArea {
        LeftDockWidgetArea = 0x1,
        RightDockWidgetArea = 0x2,
        TopDockWidgetArea = 0x4,
        BottomDockWidgetArea = 0x8,

        DockWidgetArea_Mask = 0xf,
        AllDockWidgetAreas = DockWidgetArea_Mask
    };
    enum {
        NDockWidgetAreas = 4
    };

    typedef QFlags<DockWidgetArea> DockWidgetAreas;

    enum ToolBarArea {
        LeftToolBarArea = 0x1,
        RightToolBarArea = 0x2,
        TopToolBarArea = 0x4,
        BottomToolBarArea = 0x8,

        ToolBarArea_Mask = 0xf,
        AllToolBarAreas = ToolBarArea_Mask
    };

    enum {
        NToolBarAreas = 4
    };

    typedef QFlags<ToolBarArea> ToolBarAreas;


    enum Dock {
        DockUnmanaged,
        DockTornOff,
        DockTop,
        DockBottom,
        DockRight,
        DockLeft,
        DockMinimized
        ,
        Unmanaged = DockUnmanaged,
        TornOff = DockTornOff,
        Top = DockTop,
        Bottom = DockBottom,
        Right = DockRight,
        Left = DockLeft,
        Minimized = DockMinimized
    };
    
    typedef Dock ToolBarDock;


    enum DateFormat {
        TextDate,      
        ISODate,       
        LocalDate      
    };

    enum TimeSpec {
        LocalTime,
        UTC
    };

    enum DayOfWeek {
        Monday = 1,
        Tuesday = 2,
        Wednesday = 3,
        Thursday = 4,
        Friday = 5,
        Saturday = 6,
        Sunday = 7
    };

    enum ScrollBarPolicy {
        ScrollBarAsNeeded,
        ScrollBarAlwaysOff,
        ScrollBarAlwaysOn
    };


    enum BackgroundMode {
        FixedColor,
        FixedPixmap,
        NoBackground,
        PaletteForeground,
        PaletteButton,
        PaletteLight,
        PaletteMidlight,
        PaletteDark,
        PaletteMid,
        PaletteText,
        PaletteBrightText,
        PaletteBase,
        PaletteBackground,
        PaletteShadow,
        PaletteHighlight,
        PaletteHighlightedText,
        PaletteButtonText,
        PaletteLink,
        PaletteLinkVisited,
        X11ParentRelative
    };


    enum CaseSensitivity {
        CaseInsensitive,
        CaseSensitive
    };

    enum Corner {
        TopLeftCorner = 0x00000,
        TopRightCorner = 0x00001,
        BottomLeftCorner = 0x00002,
        BottomRightCorner = 0x00003

        ,TopLeft = TopLeftCorner,
        TopRight = TopRightCorner,
        BottomLeft = BottomLeftCorner,
        BottomRight = BottomRightCorner

    };

    enum ConnectionType {
        AutoConnection,
        DirectConnection,
        QueuedConnection,
        AutoCompatConnection
    };

    enum ShortcutContext {
        WidgetShortcut,
        WindowShortcut,
        ApplicationShortcut
    };

    enum FillRule {
        OddEvenFill,
        WindingFill
    };

    enum ClipOperation {
        NoClip,
        ReplaceClip,
        IntersectClip,
        UniteClip
    };

    enum TransformationMode {
        FastTransformation,
        SmoothTransformation
    };

    enum FocusReason {
        MouseFocusReason,
        TabFocusReason,
        BacktabFocusReason,
        ActiveWindowFocusReason,
        PopupFocusReason,
        ShortcutFocusReason,
        MenuBarFocusReason,
        OtherFocusReason,
        NoFocusReason
    };

    enum ContextMenuPolicy {
        NoContextMenu,
        DefaultContextMenu,
        ActionsContextMenu,
        CustomContextMenu
    };

    enum InputMethodQuery {
        ImMicroFocus,
        ImFont,
        ImCursorPosition,
        ImSurroundingText,
        ImCurrentSelection
    };

    enum ToolButtonStyle {
        ToolButtonIconOnly,
        ToolButtonTextOnly,
        ToolButtonTextBesideIcon,
        ToolButtonTextUnderIcon
    };

    enum LayoutDirection {
        LeftToRight,
        RightToLeft
    };

    enum DropAction {
        CopyAction = 0x1,
        MoveAction = 0x2,
        LinkAction = 0x4,
        ActionMask = 0xff,
        TargetMoveAction = 0x8002,
        IgnoreAction = 0x0
    };
    typedef QFlags<DropAction> DropActions;

    enum CheckState {
        Unchecked,
        PartiallyChecked,
        Checked
    };

    enum ItemDataRole {
        DisplayRole = 0,
        DecorationRole = 1,
        EditRole = 2,
        ToolTipRole = 3,
        StatusTipRole = 4,
        WhatsThisRole = 5,
        
        FontRole = 6,
        TextAlignmentRole = 7,
        BackgroundColorRole = 8,
        TextColorRole = 9,
        CheckStateRole = 10,
        
        AccessibleTextRole = 11,
        AccessibleDescriptionRole = 12,
        
        SizeHintRole = 13,
        
        UserRole = 32
    };

    enum ItemFlag {
        ItemIsSelectable = 1,
        ItemIsEditable = 2,
        ItemIsDragEnabled = 4,
        ItemIsDropEnabled = 8,
        ItemIsUserCheckable = 16,
        ItemIsEnabled = 32,
        ItemIsTristate = 64
    };
    typedef QFlags<ItemFlag> ItemFlags;

    enum MatchFlag {
        MatchExactly = 0,
        MatchContains = 1,
        MatchStartsWith = 2,
        MatchEndsWith = 3,
        MatchRegExp = 4,
        MatchWildcard = 5,
        MatchCaseSensitive = 16,
        MatchWrap = 32,
        MatchRecursive = 64
    };
    typedef QFlags<MatchFlag> MatchFlags;






    typedef unsigned long HANDLE;



    typedef WindowFlags WFlags;

    enum WindowModality {
        NonModal,
        WindowModal,
        ApplicationModal
    };

}





inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, Qt::MouseButtons::enum_type f2) { return QFlags<Qt::MouseButtons::enum_type>(f1) | f2; } inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, QFlags<Qt::MouseButtons::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, Qt::Orientations::enum_type f2) { return QFlags<Qt::Orientations::enum_type>(f1) | f2; } inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, QFlags<Qt::Orientations::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, Qt::KeyboardModifiers::enum_type f2) { return QFlags<Qt::KeyboardModifiers::enum_type>(f1) | f2; } inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, QFlags<Qt::KeyboardModifiers::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, Qt::WindowFlags::enum_type f2) { return QFlags<Qt::WindowFlags::enum_type>(f1) | f2; } inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, QFlags<Qt::WindowFlags::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, Qt::Alignment::enum_type f2) { return QFlags<Qt::Alignment::enum_type>(f1) | f2; } inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, QFlags<Qt::Alignment::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, Qt::ImageConversionFlags::enum_type f2) { return QFlags<Qt::ImageConversionFlags::enum_type>(f1) | f2; } inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, QFlags<Qt::ImageConversionFlags::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, Qt::DockWidgetAreas::enum_type f2) { return QFlags<Qt::DockWidgetAreas::enum_type>(f1) | f2; } inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, QFlags<Qt::DockWidgetAreas::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, Qt::ToolBarAreas::enum_type f2) { return QFlags<Qt::ToolBarAreas::enum_type>(f1) | f2; } inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, QFlags<Qt::ToolBarAreas::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, Qt::WindowStates::enum_type f2) { return QFlags<Qt::WindowStates::enum_type>(f1) | f2; } inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, QFlags<Qt::WindowStates::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, Qt::DropActions::enum_type f2) { return QFlags<Qt::DropActions::enum_type>(f1) | f2; } inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, QFlags<Qt::DropActions::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, Qt::ItemFlags::enum_type f2) { return QFlags<Qt::ItemFlags::enum_type>(f1) | f2; } inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, QFlags<Qt::ItemFlags::enum_type> f2) { return f2 | f1; }
inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, Qt::MatchFlags::enum_type f2) { return QFlags<Qt::MatchFlags::enum_type>(f1) | f2; } inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, QFlags<Qt::MatchFlags::enum_type> f2) { return f2 | f1; }

class  QInternal {
public:
    enum PaintDeviceFlags {
        UnknownDevice = 0x00,
        Widget        = 0x01,
        Pixmap        = 0x02,
        Image         = 0x03,
        Printer       = 0x04,
        Picture       = 0x05,
        Pbuffer       = 0x06
    };
    enum RelayoutType {
        RelayoutNormal,
        RelayoutDragging,
        RelayoutDropped
    };
};


typedef qint32 QCOORD;                                
enum {
    QCOORD_MAX =  2147483647,
    QCOORD_MIN = -QCOORD_MAX - 1
};




#line 2 "../../include/QtCore/qnamespace.h"
#line 26 "../../include/QtCore/../../src/corelib/kernel/qobjectdefs.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class QString;

class QByteArray;








#line 66 "../../include/QtCore/../../src/corelib/kernel/qobjectdefs.h"




#line 85 "../../include/QtCore/../../src/corelib/kernel/qobjectdefs.h"

 
#line 95 "../../include/QtCore/../../src/corelib/kernel/qobjectdefs.h"
 

 
#line 124 "../../include/QtCore/../../src/corelib/kernel/qobjectdefs.h"


#line 135 "../../include/QtCore/../../src/corelib/kernel/qobjectdefs.h"


















class QObject;
class QMetaMethod;
class QMetaEnum;
class QMetaProperty;
class QMetaClassInfo;


class  QGenericArgument
{
public:
    inline QGenericArgument(const char *aName = 0, const void *aData = 0)
        : _data(aData), _name(aName) {}
    inline void *data() const { return const_cast<void *>(_data); }
    inline const char *name() const { return _name; }

private:
    const void *_data;
    const char *_name;
};

class  QGenericReturnArgument: public QGenericArgument
{
public:
    inline QGenericReturnArgument(const char *aName = 0, void *aData = 0)
        : QGenericArgument(aName, aData)
        {}
};

template <class T>
class QArgument: public QGenericArgument
{
public:
    inline QArgument(const char *aName, const T &aData)
        : QGenericArgument(aName, static_cast<const void *>(&aData))
        {}
};


template<class T>
class QReturnArgument: public QGenericReturnArgument
{
public:
    inline QReturnArgument(const char *aName, T &aData)
        : QGenericReturnArgument(aName, static_cast<void *>(&aData))
        {}
};

struct  QMetaObject
{
    const char *className() const;
    const QMetaObject *superClass() const;

    QObject *cast(QObject *obj) const;


    QString tr(const char *s, const char *c) const;
    QString trUtf8(const char *s, const char *c) const;


    int methodOffset() const;
    int enumeratorOffset() const;
    int propertyOffset() const;
    int classInfoOffset() const;

    int methodCount() const;
    int enumeratorCount() const;
    int propertyCount() const;
    int classInfoCount() const;

    int indexOfMethod(const char *method) const;
    int indexOfSignal(const char *signal) const;
    int indexOfSlot(const char *slot) const;
    int indexOfEnumerator(const char *name) const;
    int indexOfProperty(const char *name) const;
    int indexOfClassInfo(const char *name) const;

    QMetaMethod method(int index) const;
    QMetaEnum enumerator(int index) const;
    QMetaProperty property(int index) const;
    QMetaClassInfo classInfo(int index) const;

    static bool checkConnectArgs(const char *signal, const char *method);
    static QByteArray normalizedSignature(const char *method);

    
    static bool connect(const QObject *sender, int signal_index,
                        const QObject *receiver, int method_index,
                        int type = 0, int *types = 0);
    
    static bool disconnect(const QObject *sender, int signal_index,
                           const QObject *receiver, int method_index);
    
    static void connectSlotsByName(QObject *o);

    
    static void activate(QObject *sender, int signal_index, void **argv);
    static void activate(QObject *sender, int from_signal_index, int to_signal_index, void **argv);
    static void activate(QObject *sender, const QMetaObject *, int local_signal_index, void **argv);
    static void activate(QObject *sender, const QMetaObject *, int from_local_signal_index, int to_local_signal_index, void **argv);
    
    static void addGuard(QObject **ptr);
    static void removeGuard(QObject **ptr);
    static void changeGuard(QObject **ptr, QObject *o);

    static bool invokeMethod(QObject *obj, const char *member,
                             Qt::ConnectionType,
                             QGenericReturnArgument ret,
                             QGenericArgument val0 = QGenericArgument(0),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument());

    static inline bool invokeMethod(QObject *obj, const char *member,
                             QGenericReturnArgument ret,
                             QGenericArgument val0 = QGenericArgument(0),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument())
    {
        return invokeMethod(obj, member, Qt::AutoConnection, ret, val0, val1, val2, val3,
                val4, val5, val6, val7, val8, val9);
    }

    static inline bool invokeMethod(QObject *obj, const char *member,
                             Qt::ConnectionType type,
                             QGenericArgument val0 = QGenericArgument(0),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument())
    {
        return invokeMethod(obj, member, type, QGenericReturnArgument(), val0, val1, val2,
                                 val3, val4, val5, val6, val7, val8, val9);
    }


    static inline bool invokeMethod(QObject *obj, const char *member,
                             QGenericArgument val0 = QGenericArgument(0),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument())
    {
        return invokeMethod(obj, member, Qt::AutoConnection, QGenericReturnArgument(), val0,
                val1, val2, val3, val4, val5, val6, val7, val8, val9);
    }

    enum Call {
        InvokeMetaMethod,
        ReadProperty,
        WriteProperty,
        ResetProperty,
        QueryPropertyDesignable,
        QueryPropertyScriptable,
        QueryPropertyStored,
        QueryPropertyEditable,
        QueryPropertyUser
    };


     const char *superClassName() const;


    struct { 
        const QMetaObject *superdata;
        const char *stringdata;
        const uint *data;
        const QMetaObject **extradata;
    } d;
};

inline const char *QMetaObject::className() const
{ return d.stringdata; }

inline const QMetaObject *QMetaObject::superClass() const
{ return d.superdata; }


inline const char *QMetaObject::superClassName() const
{ return d.superdata ? d.superdata->className() : 0; }




#line 2 "../../include/QtCore/qobjectdefs.h"
#line 28 "../../include/QtCore/../../src/corelib/kernel/qobject.h"
#line 1 "../../include/QtCore/qstring.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qstring.h"



















 




#line 1 "../../include/QtCore/qchar.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qstring.h"
#line 1 "../../include/QtCore/qbytearray.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qbytearray.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qbytearray.h"
#line 1 "../../include/QtCore/qatomic.h"
#line 27 "../../include/QtCore/../../src/corelib/tools/qbytearray.h"

#line 1 "/usr/include/stdarg.h"










  



#ident	"@(#)unixsrc:usr/src/i386/head/stdarg.h /main/3"


extern "C" {


#line 35 "/usr/include/stdarg.h"



	typedef void *	va_list;


extern void	va_end(va_list);

	 
#line 50 "/usr/include/stdarg.h"

	 
#line 58 "/usr/include/stdarg.h"






#line 112 "/usr/include/stdarg.h"


}


#line 30 "../../include/QtCore/../../src/corelib/tools/qbytearray.h"







typedef QtValidLicenseForCoreModule QtCoreModule;



 

 char *qstrdup(const char *);

inline uint qstrlen(const char *str)
{ return str ? uint(strlen(str)) : 0; }

 char *qstrcpy(char *dst, const char *src);
 char *qstrncpy(char *dst, const char *src, uint len);

 int qstrcmp(const char *str1, const char *str2);

inline int qstrncmp(const char *str1, const char *str2, uint len)
{
    return (str1 && str2) ? strncmp(str1, str2, len)
        : (str1 ? 1 : (str2 ? -1 : 0));
}
 int qstricmp(const char *, const char *);
 int qstrnicmp(const char *, const char *, uint len);


 int qvsnprintf(char *str, size_t n, const char *fmt, va_list ap);
 int qsnprintf(char *str, size_t n, const char *fmt, ...);


inline  void *qmemmove(void *dst, const void *src, uint len)
{ return memmove(dst, src, len); }
inline  uint cstrlen(const char *str)
{ return uint(strlen(str)); }
inline  char *cstrcpy(char *dst, const char *src)
{ return qstrcpy(dst,src); }
inline  int cstrcmp(const char *str1, const char *str2)
{ return strcmp(str1,str2); }
inline  int cstrncmp(const char *str1, const char *str2, uint len)
{ return strncmp(str1,str2,len); }




 quint16 qChecksum(const char *s, uint len);

class QByteRef;
class QString;
class QDataStream;
template <typename T> class QList;

class  QByteArray
{
public:
    inline QByteArray();
    QByteArray(const char *);
    QByteArray(const char *, int size);
    QByteArray(int size, char c);
    inline QByteArray(const QByteArray &);
    inline ~QByteArray();

    QByteArray &operator=(const QByteArray &);
    QByteArray &operator=(const char *str);

    inline int size() const;
    bool isEmpty() const;
    void resize(int size);

    QByteArray &fill(char c, int size = -1);

    int capacity() const;
    void reserve(int size);
    void squeeze();

    operator const char *() const;
    operator const void *() const;
    char *data();
    const char *data() const;
    inline const char *constData() const;
    inline void detach();
    bool isDetached() const;
    void clear();

    const char at(int i) const;
    const char operator[](int i) const;
    QByteRef operator[](int i);
    const char operator[](uint i) const;
    QByteRef operator[](uint i);

    int indexOf(char c, int from = 0) const;
    inline int indexOf(const char *c, int from = 0) const;
    int indexOf(const QByteArray &a, int from = 0) const;
    int lastIndexOf(char c, int from = -1) const;
    inline int lastIndexOf(const char *c, int from = -1) const;
    int lastIndexOf(const QByteArray &a, int from = -1) const;

    QBool contains(char c) const;
    QBool contains(const char *a) const;
    QBool contains(const QByteArray &a) const;
    int count(char c) const;
    int count(const char *a) const;
    int count(const QByteArray &a) const;

    QByteArray left(int len) const;
    QByteArray right(int len) const;
    QByteArray mid(int index, int len = -1) const;

    bool startsWith(const QByteArray &a) const;
    bool startsWith(char c) const;
    bool startsWith(const char *c) const;

    bool endsWith(const QByteArray &a) const;
    bool endsWith(char c) const;
    bool endsWith(const char *c) const;

    void truncate(int pos);
    void chop(int n);

    QByteArray toLower() const;
    QByteArray toUpper() const;

    QByteArray trimmed() const;
    QByteArray simplified() const;
    QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const;
    QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const;


    inline  QByteArray leftJustify(uint width, char fill = ' ', bool truncate = false) const
    { return leftJustified(int(width), fill, truncate); }
    inline  QByteArray rightJustify(uint width, char fill = ' ', bool truncate = false) const
    { return rightJustified(int(width), fill, truncate); }


    QByteArray &prepend(char c);
    QByteArray &prepend(const char *s);
    QByteArray &prepend(const QByteArray &a);
    QByteArray &append(char c);
    QByteArray &append(const char *s);
    QByteArray &append(const QByteArray &a);
    QByteArray &insert(int i, char c);
    QByteArray &insert(int i, const char *s);
    QByteArray &insert(int i, const QByteArray &a);
    QByteArray &remove(int index, int len);
    QByteArray &replace(int index, int len, const char *s);
    QByteArray &replace(int index, int len, const QByteArray &s);
    QByteArray &replace(char before, const char *after);
    QByteArray &replace(char before, const QByteArray &after);
    QByteArray &replace(const char *before, const char *after);
    QByteArray &replace(const QByteArray &before, const QByteArray &after);
    QByteArray &replace(const QByteArray &before, const char *after);
    QByteArray &replace(const char *before, const QByteArray &after);
    QByteArray &replace(char before, char after);
    QByteArray &operator+=(char c);
    QByteArray &operator+=(const char *s);
    QByteArray &operator+=(const QByteArray &a);

    QList<QByteArray> split(char sep) const;

#line 206 "../../include/QtCore/../../src/corelib/tools/qbytearray.h"
    inline bool operator==(const QString &s2) const;
    inline bool operator!=(const QString &s2) const;
    inline bool operator<(const QString &s2) const;
    inline bool operator>(const QString &s2) const;
    inline bool operator<=(const QString &s2) const;
    inline bool operator>=(const QString &s2) const;


    short toShort(bool *ok = 0, int base = 10) const;
    ushort toUShort(bool *ok = 0, int base = 10) const;
    int toInt(bool *ok = 0, int base = 10) const;
    uint toUInt(bool *ok = 0, int base = 10) const;
    long toLong(bool *ok = 0, int base = 10) const;
    ulong toULong(bool *ok = 0, int base = 10) const;
    qlonglong toLongLong(bool *ok = 0, int base = 10) const;
    qulonglong toULongLong(bool *ok = 0, int base = 10) const;
    float toFloat(bool *ok = 0) const;
    double toDouble(bool *ok = 0) const;
    QByteArray toBase64() const;

    QByteArray &setNum(short, int base = 10);
    QByteArray &setNum(ushort, int base = 10);
    QByteArray &setNum(int, int base = 10);
    QByteArray &setNum(uint, int base = 10);
    QByteArray &setNum(qlonglong, int base = 10);
    QByteArray &setNum(qulonglong, int base = 10);
    QByteArray &setNum(float, char f = 'g', int prec = 6);
    QByteArray &setNum(double, char f = 'g', int prec = 6);

    static QByteArray number(int, int base = 10);
    static QByteArray number(uint, int base = 10);
    static QByteArray number(qlonglong, int base = 10);
    static QByteArray number(qulonglong, int base = 10);
    static QByteArray number(double, char f = 'g', int prec = 6);
    static QByteArray fromRawData(const char *, int size);
    static QByteArray fromBase64(const QByteArray &base64);

    typedef char *iterator;
    typedef const char *const_iterator;
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    iterator begin();
    const_iterator begin() const;
    const_iterator constBegin() const;
    iterator end();
    const_iterator end() const;
    const_iterator constEnd() const;

    
    typedef const char & const_reference;
    typedef char & reference;
    void push_back(char c);
    void push_back(const char *c);
    void push_back(const QByteArray &a);
    void push_front(char c);
    void push_front(const char *c);
    void push_front(const QByteArray &a);

    inline int count() const { return d->size; }
    int length() const { return d->size; }
    bool isNull() const;

    

    explicit QByteArray(int size);
    inline  QByteArray& duplicate(const QByteArray& a) { *this = a; return *this; }
    inline  QByteArray& duplicate(const char *a, uint n)
    { *this = QByteArray(a, n); return *this; }
    inline  QByteArray& setRawData(const char *a, uint n)
    { *this = fromRawData(a, n); return *this; }
    inline  void resetRawData(const char *, uint) { clear(); }
    inline  QByteArray lower() const { return toLower(); }
    inline  QByteArray upper() const { return toUpper(); }
    inline  QByteArray stripWhiteSpace() const { return trimmed(); }
    inline  QByteArray simplifyWhiteSpace() const { return simplified(); }
    inline  int find(char c, int from = 0) const { return indexOf(c, from); }
    inline  int find(const char *c, int from = 0) const { return indexOf(c, from); }
    inline  int find(const QByteArray &ba, int from = 0) const { return indexOf(ba, from); }
    inline  int findRev(char c, int from = -1) const { return lastIndexOf(c, from); }
    inline  int findRev(const char *c, int from = -1) const { return lastIndexOf(c, from); }
    inline  int findRev(const QByteArray &ba, int from = -1) const { return lastIndexOf(ba, from); }






private:
    operator QNoImplicitBoolCast() const;
    struct Data {
        QBasicAtomic ref;
        int alloc, size;
        char *data;
        char array[1];
    };
    static Data shared_null;
    static Data shared_empty;
    Data *d;
    QByteArray(Data *dd, int  , int  ) : d(dd) {}
    void realloc(int alloc);
    void expand(int i);

    friend class QByteRef;
    friend class QString;
};

inline QByteArray::QByteArray(): d(&shared_null) { d->ref.ref(); }
inline QByteArray::~QByteArray() { if (!d->ref.deref()) qFree(d); }
inline int QByteArray::size() const
{ return d->size; }
inline const char QByteArray::at(int i) const
{ do {if(!(i >= 0 && i < size()))qt_assert("i >= 0 && i < size()","../../include/QtCore/../../src/corelib/tools/qbytearray.h",317);} while (0); return d->data[i]; }
inline const char QByteArray::operator[](int i) const
{ do {if(!(i >= 0 && i < size()))qt_assert("i >= 0 && i < size()","../../include/QtCore/../../src/corelib/tools/qbytearray.h",319);} while (0); return d->data[i]; }
inline const char QByteArray::operator[](uint i) const
{ do {if(!(i < uint(size())))qt_assert("i < uint(size())","../../include/QtCore/../../src/corelib/tools/qbytearray.h",321);} while (0); return d->data[i]; }
inline bool QByteArray::isEmpty() const
{ return d->size == 0; }
inline QByteArray::operator const char *() const
{ return d->data; }
inline QByteArray::operator const void *() const
{ return d->data; }
inline char *QByteArray::data()
{ detach(); return d->data; }
inline const char *QByteArray::data() const
{ return d->data; }
inline const char *QByteArray::constData() const
{ return d->data; }
inline void QByteArray::detach()
{ if (d->ref != 1 || d->data != d->array) realloc(d->size); }
inline bool QByteArray::isDetached() const
{ return d->ref == 1; }
inline QByteArray::QByteArray(const QByteArray &a) : d(a.d)
{ d->ref.ref(); }

inline QByteArray::QByteArray(int size) : d(&shared_null)
{ d->ref.ref(); if (size > 0) fill('\0', size); }


inline int QByteArray::capacity() const
{ return d->alloc; }

inline void QByteArray::reserve(int asize)
{ if (d->ref != 1 || asize > d->alloc) realloc(asize); }

inline void QByteArray::squeeze()
{ if (d->size < d->alloc) realloc(d->size); }

class  QByteRef {
    QByteArray &a;
    int i;
    inline QByteRef(QByteArray &array, int idx)
        : a(array),i(idx) {}
    friend class QByteArray;
public:
    inline operator const char() const
        { return i < a.d->size ? a.d->data[i] : 0; }
    inline QByteRef &operator=(char c)
        { if (a.d->ref != 1 || i >= a.d->size) a.expand(i);
          a.d->data[i] = c;  return *this; }
    inline QByteRef &operator=(const QByteRef &c)
        { if (a.d->ref != 1 || i >= a.d->size) a.expand(i);
          a.d->data[i] = c.a.d->data[c.i];  return *this; }
    inline bool operator==(char c) const
    { return a.d->data[i] == c; }
    inline bool operator!=(char c) const
    { return a.d->data[i] != c; }
    inline bool operator>(char c) const
    { return a.d->data[i] > c; }
    inline bool operator>=(char c) const
    { return a.d->data[i] >= c; }
    inline bool operator<(char c) const
    { return a.d->data[i] < c; }
    inline bool operator<=(char c) const
    { return a.d->data[i] <= c; }
};

inline QByteRef QByteArray::operator[](int i)
{ do {if(!(i >= 0))qt_assert("i >= 0","../../include/QtCore/../../src/corelib/tools/qbytearray.h",384);} while (0); return QByteRef(*this, i); }
inline QByteRef QByteArray::operator[](uint i)
{ return QByteRef(*this, i); }
inline QByteArray::iterator QByteArray::begin()
{ detach(); return d->data; }
inline QByteArray::const_iterator QByteArray::begin() const
{ return d->data; }
inline QByteArray::const_iterator QByteArray::constBegin() const
{ return d->data; }
inline QByteArray::iterator QByteArray::end()
{ detach(); return d->data + d->size; }
inline QByteArray::const_iterator QByteArray::end() const
{ return d->data + d->size; }
inline QByteArray::const_iterator QByteArray::constEnd() const
{ return d->data + d->size; }
inline QByteArray &QByteArray::operator+=(char c)
{ return append(c); }
inline QByteArray &QByteArray::operator+=(const char *s)
{ return append(s); }
inline QByteArray &QByteArray::operator+=(const QByteArray &a)
{ return append(a); }
inline void QByteArray::push_back(char c)
{ append(c); }
inline void QByteArray::push_back(const char *c)
{ append(c); }
inline void QByteArray::push_back(const QByteArray &a)
{ append(a); }
inline void QByteArray::push_front(char c)
{ prepend(c); }
inline void QByteArray::push_front(const char *c)
{ prepend(c); }
inline void QByteArray::push_front(const QByteArray &a)
{ prepend(a); }
inline QBool QByteArray::contains(const QByteArray &a) const
{ return QBool(indexOf(a) != -1); }
inline QBool QByteArray::contains(char c) const
{ return QBool(indexOf(c) != -1); }
inline bool operator==(const QByteArray &a1, const QByteArray &a2)
{ return (a1.size() == a2.size()) && (memcmp(a1, a2, a1.size())==0); }
inline bool operator==(const QByteArray &a1, const char *a2)
{ return a2 ? strcmp(a1,a2) == 0 : a1.isEmpty(); }
inline bool operator==(const char *a1, const QByteArray &a2)
{ return a1 ? strcmp(a1,a2) == 0 : a2.isEmpty(); }
inline bool operator!=(const QByteArray &a1, const QByteArray &a2)
{ return !(a1==a2); }
inline bool operator!=(const QByteArray &a1, const char *a2)
{ return a2 ? strcmp(a1,a2) != 0 : !a1.isEmpty(); }
inline bool operator!=(const char *a1, const QByteArray &a2)
{ return a1 ? strcmp(a1,a2) != 0 : !a2.isEmpty(); }
inline bool operator<(const QByteArray &a1, const QByteArray &a2)
{ return strcmp(a1, a2) < 0; }
 inline bool operator<(const QByteArray &a1, const char *a2)
{ return qstrcmp(a1, a2) < 0; }
inline bool operator<(const char *a1, const QByteArray &a2)
{ return qstrcmp(a1, a2) < 0; }
inline bool operator<=(const QByteArray &a1, const QByteArray &a2)
{ return strcmp(a1, a2) <= 0; }
inline bool operator<=(const QByteArray &a1, const char *a2)
{ return qstrcmp(a1, a2) <= 0; }
inline bool operator<=(const char *a1, const QByteArray &a2)
{ return qstrcmp(a1, a2) <= 0; }
inline bool operator>(const QByteArray &a1, const QByteArray &a2)
{ return strcmp(a1, a2) > 0; }
inline bool operator>(const QByteArray &a1, const char *a2)
{ return qstrcmp(a1, a2) > 0; }
inline bool operator>(const char *a1, const QByteArray &a2)
{ return qstrcmp(a1, a2) > 0; }
inline bool operator>=(const QByteArray &a1, const QByteArray &a2)
{ return strcmp(a1, a2) >= 0; }
inline bool operator>=(const QByteArray &a1, const char *a2)
{ return qstrcmp(a1, a2) >= 0; }
inline bool operator>=(const char *a1, const QByteArray &a2)
{ return qstrcmp(a1, a2) >= 0; }
inline const QByteArray operator+(const QByteArray &a1, const QByteArray &a2)
{ return QByteArray(a1) += a2; }
inline const QByteArray operator+(const QByteArray &a1, const char *a2)
{ return QByteArray(a1) += a2; }
inline const QByteArray operator+(const QByteArray &a1, char a2)
{ return QByteArray(a1) += a2; }
inline const QByteArray operator+(const char *a1, const QByteArray &a2)
{ return QByteArray(a1) += a2; }
inline const QByteArray operator+(char a1, const QByteArray &a2)
{ return QByteArray(&a1, 1) += a2; }
inline int QByteArray::indexOf(const char *c, int i) const
{ return indexOf(fromRawData(c, qstrlen(c)), i); }
inline int QByteArray::lastIndexOf(const char *c, int i) const
{ return lastIndexOf(fromRawData(c, qstrlen(c)), i); }
inline QBool QByteArray::contains(const char *c) const
{ return contains(fromRawData(c, qstrlen(c))); }
inline QByteArray &QByteArray::replace(int index, int len, const char *c)
{ return replace(index, len, fromRawData(c, qstrlen(c))); }
inline QByteArray &QByteArray::replace(char before, const char *c)
{ return replace(before, fromRawData(c, qstrlen(c))); }
inline QByteArray &QByteArray::replace(const QByteArray &before, const char *c)
{ return replace(before, fromRawData(c, qstrlen(c))); }
inline QByteArray &QByteArray::replace(const char *c, const QByteArray &after)
{ return replace(fromRawData(c, qstrlen(c)), after); }
inline QByteArray &QByteArray::replace(const char *before, const char *after)
{ return replace(fromRawData(before, qstrlen(before)), fromRawData(after, qstrlen(after))); }

inline QByteArray &QByteArray::setNum(short n, int base)
{ return setNum(qlonglong(n), base); }
inline QByteArray &QByteArray::setNum(ushort n, int base)
{ return setNum(qulonglong(n), base); }
inline QByteArray &QByteArray::setNum(int n, int base)
{ return setNum(qlonglong(n), base); }
inline QByteArray &QByteArray::setNum(uint n, int base)
{ return setNum(qulonglong(n), base); }
inline QByteArray &QByteArray::setNum(float n, char f, int prec)
{ return setNum(double(n),f,prec); }



 QDataStream &operator<<(QDataStream &, const QByteArray &);
 QDataStream &operator>>(QDataStream &, QByteArray &);



 QByteArray qCompress(const uchar* data, int nbytes, int compressionLevel = -1);
 QByteArray qUncompress(const uchar* data, int nbytes);
inline QByteArray qCompress(const QByteArray& data, int compressionLevel = -1)
{ return qCompress(reinterpret_cast<const uchar *>(data.constData()), data.size(), compressionLevel); }
inline QByteArray qUncompress(const QByteArray& data)
{ return qUncompress(reinterpret_cast<const uchar*>(data.constData()), data.size()); }


template <> class QTypeInfo<QByteArray> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QByteArray)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QByteArray"; } };
template <> inline bool qIsDetached<QByteArray>(QByteArray &t) { return t . isDetached(); }



#line 2 "../../include/QtCore/qbytearray.h"
#line 27 "../../include/QtCore/../../src/corelib/tools/qstring.h"
#line 1 "../../include/QtCore/qatomic.h"
#line 28 "../../include/QtCore/../../src/corelib/tools/qstring.h"
#line 1 "../../include/QtCore/qnamespace.h"
#line 29 "../../include/QtCore/../../src/corelib/tools/qstring.h"




#line 1 "/usr/include/CC/string"

#line 1 "/usr/include/CC/istream"

#line 1 "/usr/include/CC/ostream"

#line 1 "/usr/include/CC/ios"

#line 1 "/usr/include/CC/xlocnum"

#line 1 "/usr/include/CC/cerrno"

#line 1 "/usr/include/errno.h"










  



#ident	"@(#)unixsrc:usr/src/common/head/errno.h /main/1"

#line 1 "/usr/include/sys/errno.h"



#ident	"@(#)unixsrc:usr/src/common/uts/svc/errno.h /main/1"
#ident	"$Header: $"


extern "C" {









 



 

#line 70 "/usr/include/sys/errno.h"

 
#line 79 "/usr/include/sys/errno.h"



 






#line 95 "/usr/include/sys/errno.h"

#line 105 "/usr/include/sys/errno.h"

 
#line 119 "/usr/include/sys/errno.h"

 


 
	 
#line 138 "/usr/include/sys/errno.h"
	 
#line 148 "/usr/include/sys/errno.h"
 
#line 158 "/usr/include/sys/errno.h"

 





 
 
#line 174 "/usr/include/sys/errno.h"
 

#line 183 "/usr/include/sys/errno.h"

 

 





 
#line 207 "/usr/include/sys/errno.h"


        }
#line 18 "/usr/include/errno.h"

#line 34 "/usr/include/errno.h"

extern int	errno;







#line 5 "/usr/include/CC/cerrno"





 
#line 5 "/usr/include/CC/xlocnum"
#line 1 "/usr/include/CC/streambuf"

#line 1 "/usr/include/CC/xiosbase"

#line 1 "/usr/include/CC/xlocale"

#line 1 "/usr/include/CC/stdexcept"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/stdexcept /main/1"

#line 7 "/usr/include/CC/xlocale"
#line 1 "/usr/include/CC/typeinfo"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/typeinfo /main/1"
 


 



#line 1 "/usr/include/CC/exception"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/exception /main/1"

#line 10 "/usr/include/CC/typeinfo"


namespace std {


  

 

  typedef bool __bool;





 
#pragma define_type_info
  class type_info {
  public:
    virtual ~type_info();
    __bool operator==(const type_info&) const;
    __bool operator!=(const type_info&) const;
    __bool before(const type_info&) const;
    const char* name() const;
  private:
    type_info& operator=(const type_info&);  


  protected:
    
    

    type_info(const type_info&);  
  };

  class bad_cast : public exception {
  public:
    bad_cast() throw();
    bad_cast(const bad_cast&) throw();
    bad_cast& operator=(const bad_cast&) throw();
    virtual ~bad_cast() throw();
    virtual const char* what() const throw();
  };

  class bad_typeid : public exception {
  public:
    bad_typeid() throw();
    bad_typeid(const bad_typeid&) throw();
    bad_typeid& operator=(const bad_typeid&) throw();
    virtual ~bad_typeid() throw();
    virtual const char* what() const throw();
  };


}   









#line 8 "/usr/include/CC/xlocale"
#line 1 "/usr/include/CC/xlocinfo"

#line 1 "/usr/include/CC/xlocinfo.h"
 
#line 1 "/usr/include/ctype.h"










  



#ident	"@(#)unixsrc:usr/src/common/head/ctype.h /main/1"

#line 27 "/usr/include/ctype.h"


extern "C" {


extern unsigned char	__ctype[];

extern int	isalnum(int);
extern int	isalpha(int);
extern int	isblank(int);
extern int	iscntrl(int);
extern int	isdigit(int);
extern int	isgraph(int);
extern int	islower(int);
extern int	isprint(int);
extern int	ispunct(int);
extern int	isspace(int);
extern int	isupper(int);
extern int	isxdigit(int);
extern int	tolower(int);
extern int	toupper(int);

extern int	isascii(int);
extern int	toascii(int);
extern int	_tolower(int);
extern int	_toupper(int);



inline int isalnum(int __1){ return (__ctype + 1)[__1] & (01 | 02 | 04); }
inline int isalpha(int __1){ return (__ctype + 1)[__1] & (01 | 02); }
inline int iscntrl(int __1){ return (__ctype + 1)[__1] & 040; }
inline int isdigit(int __1){ return (__ctype + 1)[__1] & 04; }
inline int isgraph(int __1){ return (__ctype + 1)[__1] & (020 | 01 | 02 | 04); }
inline int islower(int __1){ return (__ctype + 1)[__1] & 02; }
inline int isprint(int __1){ return (__ctype + 1)[__1] & (020|01|02|04|0100); }
inline int ispunct(int __1){ return (__ctype + 1)[__1] & 020; }
inline int isspace(int __1){ return (__ctype + 1)[__1] & 010; }
inline int isupper(int __1){ return (__ctype + 1)[__1] & 01; }
inline int isxdigit(int __1){ return (__ctype + 1)[__1] & 0200; }

inline int isascii(int __1){ return !(__1 & ~0177); }
inline int toascii(int __1){ return __1 & 0177; }



inline int _tolower(int __1){ return (__ctype + 258)[__1]; }
inline int _toupper(int __1){ return (__ctype + 258)[__1]; }


}  

#line 1 "/usr/include/CC/cctype"

#line 1 "/usr/include/ctype.h"










  

#line 5 "/usr/include/CC/cctype"



namespace std {
using ::isalnum; using ::isalpha; using ::iscntrl;
using ::isdigit; using ::isgraph; using ::islower;
using ::isprint; using ::ispunct; using ::isspace;
using ::isupper; using ::isxdigit; using ::tolower;
using ::toupper;

}	





 
#line 81 "/usr/include/ctype.h"


#line 107 "/usr/include/ctype.h"

#line 5 "/usr/include/CC/xlocinfo.h"
#line 1 "/usr/include/locale.h"










  



#ident	"@(#)unixsrc:usr/src/common/head/locale.h /main/1"

struct lconv
{
	char	*decimal_point;
	char	*thousands_sep;
	char	*grouping;
	char	*int_curr_symbol;
	char	*currency_symbol;
	char	*mon_decimal_point;
	char	*mon_thousands_sep;
	char	*mon_grouping;
	char	*positive_sign;
	char	*negative_sign;
	char	int_frac_digits;
	char	frac_digits;
	char	p_cs_precedes;
	char	p_sep_by_space;
	char	n_cs_precedes;
	char	n_sep_by_space;
	char	p_sign_posn;
	char	n_sign_posn;
			 

	char	int_p_cs_precedes;




	char	int_n_cs_precedes;




	char	int_p_sep_by_space;




	char	int_n_sep_by_space;




	char	int_p_sign_posn;




	char	int_n_sign_posn;



};

#line 77 "/usr/include/locale.h"






extern "C" {


extern char	*setlocale(int, const char *);
struct lconv	*localeconv(void);


}
#line 1 "/usr/include/CC/clocale"

#line 1 "/usr/include/locale.h"










  

#line 5 "/usr/include/CC/clocale"



namespace std {
using ::lconv; using ::localeconv; using ::setlocale;

}	





 
#line 93 "/usr/include/locale.h"



#line 6 "/usr/include/CC/xlocinfo.h"





		 
#line 22 "/usr/include/CC/xlocinfo.h"

		 
#line 33 "/usr/include/CC/xlocinfo.h"

#line 42 "/usr/include/CC/xlocinfo.h"

typedef struct _Collvec
	{	 
	int _Stuff;
	} _Collvec;

typedef struct _Ctypevec
	{	 
	int _Stuff;
	const short *_Table;
	int _Delfl;
	} _Ctypevec;

typedef struct _Cvtvec
	{	 
	int _Stuff;
	} _Cvtvec;

		 
extern "C" {
_Collvec _Getcoll();
_Ctypevec _Getctype();
_Cvtvec _Getcvt();
char *_Getdays();
char *_Getmonths();
void *_Gettnames();
int _Mbrtowc(wchar_t *, const char *, size_t,
	mbstate_t *, const _Cvtvec *);
extern float _Stof(const char *, char **, long);
extern double _Stod(const char *, char **, long);
extern long double _Stold(const char *, char **, long);
int _Strcoll(const char *, const char *,
	const char *, const char *, const _Collvec *);
size_t _Strftime(char *, size_t, const char *,
	const struct tm *, void *);
size_t _Strxfrm(char *, char *,
	const char *, const char *, const _Collvec *);
int _Tolower(int, const _Ctypevec *);
int _Toupper(int, const _Ctypevec *);
int _Wcrtomb(char *, wchar_t, mbstate_t *,
	const _Cvtvec *);
int _Wcscoll(const wchar_t *, const wchar_t *,
	const wchar_t *, const wchar_t *, const _Collvec *);
size_t _Wcsxfrm(wchar_t *, wchar_t *,
	const wchar_t *, const wchar_t *, const _Collvec *);
}





 
#line 5 "/usr/include/CC/xlocinfo"



namespace std {

		
class _Timevec
	{	
public:
	_Timevec(void *_Ptr = 0)
		: _Timeptr(_Ptr)
		{}	

	_Timevec(const _Timevec& _Right)
		{	
		*this = _Right; }

	~_Timevec()
		{	
		free(_Timeptr); }

	_Timevec& operator=(const _Timevec& _Right)
		{	
		_Timeptr = _Right._Timeptr;
		((_Timevec *)&_Right)->_Timeptr = 0;
		return (*this); }

	void *_Getptr() const
		{	
		return (_Timeptr); }

private:
	void *_Timeptr;	
	};

		
class _Locinfo
	{	
public:
	typedef ::_Collvec _Collvec;
	typedef ::_Ctypevec _Ctypevec;
	typedef ::_Cvtvec _Cvtvec;
	typedef std::_Timevec _Timevec;

	_Locinfo(const char * = "C");	

	_Locinfo(int, const char *);	

	~_Locinfo();	

	_Locinfo& _Addcats(int, const char *);	

	string _Getname() const
		{	
		return (_Newlocname); }

	_Collvec _Getcoll() const
		{	
		return (::_Getcoll()); }

	_Ctypevec _Getctype() const
		{	
		return (::_Getctype()); }

	_Cvtvec _Getcvt() const
		{	
		return (::_Getcvt()); }

	const lconv *_Getlconv() const
		{	
		return (localeconv()); }

	_Timevec _Gettnames() const
		{	
		return (_Timevec(::_Gettnames())); }

	const char *_Getdays() const
		{	
		const char *_Ptr = ::_Getdays();
		if (_Ptr != 0)
			{	
			((_Locinfo *)this)->_Days = _Ptr;
			free((void *)_Ptr); }
		return (_Days.size() != 0 ? _Days.c_str()
			: ":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:Wednesday"
				":Thu:Thursday:Fri:Friday:Sat:Saturday"); }

	const char *_Getmonths() const
		{	
		const char *_Ptr = ::_Getmonths();
		if (_Ptr != 0)
			{	
			((_Locinfo *)this)->_Months = _Ptr;
			free((void *)_Ptr); }
		return (_Months.size() != 0 ? _Months.c_str()
			: ":Jan:January:Feb:February:Mar:March"
				":Apr:April:May:May:Jun:June"
				":Jul:July:Aug:August:Sep:September"
				":Oct:October:Nov:November:Dec:December"); }

	const char *_Getfalse() const
		{	
		return ("false"); }

	const char *_Gettrue() const
		{	
		return ("true"); }

private:
	_Lockit _Lock;	
	string _Days;	
	string _Months;	
	string _Oldlocname;	
	string _Newlocname;	
	};

		
template<class _Elem> inline
	int _LStrcoll(const _Elem *_First1, const _Elem *_Last1,
		const _Elem *_First2, const _Elem *_Last2,
			const _Locinfo::_Collvec *)
	{	
	for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
		if (*_First1 < *_First2)
			return (-1);	
		else if (*_First2 < *_First1)
			return (+1);	
	return (_First2 != _Last2 ? -1 : _First1 != _Last1 ? +1 : 0); }

template<> inline
	int _LStrcoll(const char *_First1, const char *_Last1,
		const char *_First2, const char *_Last2,
			const _Locinfo::_Collvec *_Vector)
	{	
	return (_Strcoll(_First1, _Last1, _First2, _Last2, _Vector)); }

		
template<class _Elem> inline
	size_t _LStrxfrm(_Elem *_First1, _Elem *_Last1,
		const _Elem *_First2, const _Elem *_Last2,
			const _Locinfo::_Collvec *)
	{	
	size_t _Count = _Last2 - _First2;
	if (_Count <= (size_t)(_Last1 - _First1))
		memcpy(_First1, _First2, _Count * sizeof (_Elem));
	return (_Count); }

template<> inline
	size_t _LStrxfrm(char *_First1, char *_Last1,
		const char *_First2, const char *_Last2,
			const _Locinfo::_Collvec *_Vector)
	{	
	return (_Strxfrm(_First1, _Last1, _First2, _Last2, _Vector)); }

}	





 
#line 9 "/usr/include/CC/xlocale"


namespace std {

		
template<class _Dummy>
	class _Locbase
	{	
public:
	static const int collate = (1 << (3));
	static const int ctype = (1 << (0));
	static const int monetary = (1 << (4));
	static const int numeric = (1 << (1));
	static const int time = (1 << (2));
	static const int messages = (1 << (6));
	static const int all = ((1 << ((6 + 1))) - 1);
	static const int none = 0;
	};

template<class _Dummy>
	const int _Locbase<_Dummy>::collate;
template<class _Dummy>
	const int _Locbase<_Dummy>::ctype;
template<class _Dummy>
	const int _Locbase<_Dummy>::monetary;
template<class _Dummy>
	const int _Locbase<_Dummy>::numeric;
template<class _Dummy>
	const int _Locbase<_Dummy>::time;
template<class _Dummy>
	const int _Locbase<_Dummy>::messages;
template<class _Dummy>
	const int _Locbase<_Dummy>::all;
template<class _Dummy>
	const int _Locbase<_Dummy>::none;

		
class locale
	: public _Locbase<int>
	{	
public:
	typedef int category;

			
	class id
		{	
	public:
		id(size_t _Val = 0)
			: _Id(_Val)
			{}	

		operator size_t()
			{	
			_Lockit _Lock(0);
			if (_Id == 0)
				_Id = ++_Id_cnt;
			return (_Id); }

	private:
		id(const id&);	
		id& operator=(const id&);	

		size_t _Id;	
		static int _Id_cnt;	
		};

	class _Locimp;

			
	class facet
		{	
		friend class locale;
		friend class _Locimp;

	public:
		static size_t _Getcat(const facet ** = 0)
			{	
			return ((size_t)(-1)); }

		void _Incref()
			{	
			_Lockit _Lock(0);

			if (_Refs < (size_t)(-1))
				++_Refs; }

		facet *_Decref()
			{	
			_Lockit _Lock(0);

			if (0 < _Refs && _Refs < (size_t)(-1))
				--_Refs;
			return (_Refs == 0 ? this : 0); }


		virtual ~facet()
			{}	

	protected:
		explicit facet(size_t _Initrefs = 0)
			: _Refs(_Initrefs)
			{}	

	private:
		facet(const facet&);	
		facet& operator=(const facet&);	

		size_t _Refs;	
		};

			
	class _Locimp
		: public facet
		{	
	protected:
		~_Locimp();	

	private:
		friend class locale;

		_Locimp(bool _Transparent = false);	

		_Locimp(const _Locimp&);	

		void _Addfac(facet *, size_t);	

		static _Locimp *_Makeloc(const _Locinfo&,
			category, _Locimp *, const locale *);	

		static void _Makewloc(const _Locinfo&,
			category, _Locimp *, const locale *);	

		static void _Makexloc(const _Locinfo&,
			category, _Locimp *, const locale *);	

		facet **_Facetvec;	
		size_t _Facetcount;	
		category _Catmask;	
		bool _Xparent;	
		string _Name;	
		static _Locimp *_Clocptr;	
		static _Locimp *_Global;	
		};

	template<class _Elem,
		class _Tr,
		class _Alloc>
		bool operator()(const basic_string<_Elem, _Tr, _Alloc>&,
			const basic_string<_Elem, _Tr, _Alloc>&) const;	

	template<class _Facet>
		locale combine(const locale& _Right) const;	

	template<class _Facet>
		locale(const locale& _Right, _Facet *_Facptr)
			: _Ptr(new _Locimp(_Right._Ptr))
		{	
		if (_Facptr != 0)
			{	
			_Ptr->_Addfac(_Facptr, _Facet::id);
			if (_Facet::_Getcat() != (size_t)(-1))
				_Ptr->_Catmask = 0, _Ptr->_Name = "*"; }}	

	locale() throw ()
		: _Ptr(_Init())
		{	
		_Locimp::_Global->_Incref(); }

	locale(_Uninitialized)
		{}	

	locale(const locale& _Right) throw ()
		: _Ptr(_Right._Ptr)
		{	
		_Ptr->_Incref(); }

	locale(const locale&, const locale&,
		category);	

	explicit locale(const char *,
		category = all);	

	locale(const locale&, const char *,
		category);	

	~locale() throw ()
		{	
		if (_Ptr != 0)
			delete _Ptr->_Decref(); }

	locale& operator=(const locale& _Right) throw ()
		{	
		if (_Ptr != _Right._Ptr)
			{	
			delete _Ptr->_Decref();
			_Ptr = _Right._Ptr;
			_Ptr->_Incref(); }
		return (*this); }

	string name() const
		{	
		return (_Ptr->_Name); }

	const facet *_Getfacet(size_t) const;	

	bool operator==(const locale&) const;	

	bool operator!=(const locale& _Right) const
		{	
		return (!(*this == _Right)); }

	static const locale& classic();	

	static locale global(const locale&);	

	static locale empty();	

private:
	locale(_Locimp *_Ptrimp)
		: _Ptr(_Ptrimp)
		{}	

	static _Locimp *_Init();	

	static void _Tidy();	

	_Locimp *_Ptr;	
	};

		
template<class _Facet>
	class _Tidyfac
	{	
public:
	static _Facet *_Save(_Facet *_Fac)
		{	
		_Facsav = _Fac;
		_Facsav->_Incref();
		
		return (_Fac); }

	static void _Tidy()
		{	
		if (_Facsav != 0)
			{	
			delete _Facsav->_Decref();
			_Facsav = 0; }}

private:
	static _Facet *_Facsav;	
	};

		
template<class _Facet>
	_Facet *_Tidyfac<_Facet>::_Facsav = 0;





template<class _Facet> inline
	const _Facet& use_facet(const locale& _Locale)
	{	
	static const locale::facet *_Psave = 0;	

	size_t _Id = _Facet::id;
	const locale::facet *_Pf = _Locale._Getfacet(_Id);

	if (_Pf != 0)
		;	
	else if (_Psave != 0)
		_Pf = _Psave;	
	else
		{	
		_Lockit _Lock(0);

		if (_Psave != 0)
			_Pf = _Psave;	
		else if (_Facet::_Getcat(&_Psave) != (size_t)(-1))
			_Pf = _Tidyfac<_Facet>::_Save((_Facet *)_Psave);	
		else
			throw bad_cast(); }	

	return ((const _Facet&)(*_Pf)); }	

		


template<class _Elem> inline
	char _Narrow(_Elem _Char)
	{	
	return ((char)_Char); }	

template<> inline
	char _Narrow(wchar_t _Char)
	{	
	return ((char)wctob(_Char)); }

		


template<class _Elem> inline
	_Elem _Widen(char _Ch, _Elem *)
	{	
	return ((_Elem)(unsigned char)_Ch); }	

template<> inline
	wchar_t _Widen(char _Ch, wchar_t *)
	{	
	return (btowc(_Ch)); }

		
template<class _Elem,
	class _InIt> inline
	int _Getloctxt(_InIt& _First, _InIt& _Last, size_t _Numfields,
		const _Elem *_Ptr)
	{	
	for (size_t _Off = 0; _Ptr[_Off] != (_Elem)0; ++_Off)
		if (_Ptr[_Off] == _Ptr[0])
			++_Numfields;	
	string _Str(_Numfields, '\0');	

	int _Ans = -2;	
	for (size_t _Column = 1; ; ++_Column, ++_First, _Ans = -1)
		{	
		bool  _Prefix = false;	
		size_t _Off = 0;	
		size_t _Field = 0;	

		for (; _Field < _Numfields; ++_Field)
			{	
			for (; _Ptr[_Off] != (_Elem)0 && _Ptr[_Off] != _Ptr[0]; ++_Off)
				;	

			if (_Str[_Field] != '\0')
				_Off += _Str[_Field];	
			else if (_Ptr[_Off += _Column] == _Ptr[0]
				|| _Ptr[_Off] == (_Elem)0)
				{	
				_Str[_Field] = (char)(_Column < 127
					? _Column : 127);	
				_Ans = (int)_Field; }	
			else if (_First == _Last || _Ptr[_Off] != *_First)
				_Str[_Field] = (char)(_Column < 127
					? _Column : 127);	
			else
				_Prefix = true; }	

		if (!_Prefix || _First == _Last)
			break; }	
	return (_Ans); }	

		



template<class _Elem> inline
	_Elem *_Maklocstr(const char *_Ptr, _Elem *)
	{	
	size_t _Count = strlen(_Ptr) + 1;
	_Elem *_Ptrdest = new _Elem[_Count];

	for (_Elem *_Ptrnext = _Ptrdest; 0 < _Count; --_Count, ++_Ptrnext, ++_Ptr)
		*_Ptrnext = _Widen(*_Ptr, (_Elem *)0);
	return (_Ptrdest); }

		
class codecvt_base
	: public locale::facet
	{	
public:
	enum
		{	
		ok, partial, error, noconv};
	typedef int result;

	codecvt_base(size_t _Refs = 0)
		: locale::facet(_Refs)
		{}	

	bool always_noconv() const throw ()
		{	
		return (do_always_noconv()); }

	int max_length() const throw ()
		{	
		return (do_max_length()); }

	int encoding() const throw ()
		{	
		return (do_encoding()); }

	~codecvt_base()
		{}	

protected:
	virtual bool do_always_noconv() const throw ()
		{	
		return (true); }

	virtual int do_max_length() const throw ()
		{	
		return (1); }

	virtual int do_encoding() const throw ()
		{	
		return (1); }	
	};

		
template<class _Elem,
	class _Byte,
	class _Statype>
	class codecvt
		: public codecvt_base
	{	
public:
	typedef _Elem intern_type;
	typedef _Byte extern_type;
	typedef _Statype state_type;

	result in(_Statype& _State,
		const _Byte *_First1, const _Byte *_Last1, const _Byte *& _Mid1,
		_Elem *_First2, _Elem *_Last2, _Elem *& _Mid2) const
		{	
		return (do_in(_State,
			_First1, _Last1, _Mid1, _First2, _Last2, _Mid2)); }

	result out(_Statype& _State,
		const _Elem *_First1, const _Elem *_Last1, const _Elem *& _Mid1,
		_Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
		{	
		return (do_out(_State,
			_First1, _Last1, _Mid1, _First2, _Last2, _Mid2)); }

	result unshift(_Statype& _State,
		_Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
		{	
		return (do_unshift(_State, _First2, _Last2, _Mid2)); }

	int length(_Statype& _State, const _Byte *_First1,
		const _Byte *_Last1, size_t _Count) const throw ()
		{	
		return (do_length(_State, _First1, _Last1, _Count)); }

	static locale::id id;	

	explicit codecvt(size_t _Refs = 0)
		: codecvt_base(_Refs)
		{	
		_Init(_Locinfo()); }

	codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
		: codecvt_base(_Refs)
		{	
		_Init(_Lobj); }

	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{	
		if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new codecvt<_Elem, _Byte, _Statype>;
		return (0); }

protected:
	virtual ~codecvt()
		{}	

protected:
	void _Init(const _Locinfo& _Lobj)
		{	
		_Cvt = _Lobj._Getcvt(); }

	virtual result do_in(_Statype&,
		const _Byte *_First1, const _Byte *, const _Byte *& _Mid1,
		_Elem *_First2, _Elem *, _Elem *& _Mid2) const
		{	
		_Mid1 = _First1, _Mid2 = _First2;
		return (noconv); }	

	virtual result do_out(_Statype&,
		const _Elem *_First1, const _Elem *, const _Elem *& _Mid1,
		_Byte *_First2, _Byte *, _Byte *& _Mid2) const
		{	
		_Mid1 = _First1, _Mid2 = _First2;
		return (noconv); }	

	virtual result do_unshift(_Statype&,
		_Byte *, _Byte *, _Byte *&) const
		{	
		return (noconv); }	

	virtual int do_length(_Statype&, const _Byte *_First1,
		const _Byte *_Last1, size_t _Count) const throw ()
		{	
		return (_Count < (size_t)(_Last1 - _First1)
			? _Count : _Last1 - _First1); }	

private:
	_Locinfo::_Cvtvec _Cvt;	
	};

		
template<class _Elem,
	class _Byte,
	class _Statype>
	locale::id codecvt<_Elem, _Byte, _Statype>::id;

		
template<> class codecvt<wchar_t, char, mbstate_t>
	: public codecvt_base
	{	
public:
	typedef wchar_t _Elem;
	typedef char _Byte;
	typedef mbstate_t _Statype;
	typedef _Elem intern_type;
	typedef _Byte extern_type;
	typedef _Statype state_type;

	result in(_Statype& _State,
		const _Byte *_First1, const _Byte *_Last1, const _Byte *& _Mid1,
		_Elem *_First2, _Elem *_Last2, _Elem *& _Mid2) const
		{	
		return (do_in(_State,
			_First1, _Last1, _Mid1, _First2, _Last2, _Mid2)); }

	result out(_Statype& _State,
		const _Elem *_First1, const _Elem *_Last1, const _Elem *& _Mid1,
		_Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
		{	
		return (do_out(_State,
			_First1, _Last1, _Mid1, _First2, _Last2, _Mid2)); }

	result unshift(_Statype& _State,
		_Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
		{	
		return (do_unshift(_State,
			_First2, _Last2, _Mid2)); }

	int length(_Statype& _State, const _Byte *_First1,
		const _Byte *_Last1, size_t _N2) const throw ()
		{	
		return (do_length(_State, _First1, _Last1, _N2)); }

	static locale::id id;	

	explicit codecvt(size_t _Refs = 0)
		: codecvt_base(_Refs)
		{	
		_Init(_Locinfo()); }

	codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
		: codecvt_base(_Refs)
		{	
		_Init(_Lobj); }

	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{	
		if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new codecvt<_Elem, _Byte, _Statype>;
		return (0); }

protected:
	virtual ~codecvt()
		{}	

protected:
	void _Init(const _Locinfo& _Lobj)
		{	
		_Cvt = _Lobj._Getcvt(); }

	virtual result do_in(_Statype& _State,
		const _Byte *_First1, const _Byte *_Last1, const _Byte *& _Mid1,
		_Elem *_First2, _Elem *_Last2, _Elem *& _Mid2) const
		{	
		_Mid1 = _First1, _Mid2 = _First2;
		result _Ans = _Mid1 == _Last1 ? ok : partial;
		int _Bytes;

		while (_Mid1 != _Last1 && _Mid2 != _Last2)
			switch (_Bytes = _Mbrtowc(_Mid2, _Mid1, _Last1 - _Mid1,
				&_State, &_Cvt))
			{	
			case -2:	
				_Mid1 = _Last1;
				return (_Ans);

			case -1:	
				return (error);

			case 0:	
				_Bytes = strlen(_Mid1) + 1;
				

			default:	
				_Mid1 += _Bytes, ++_Mid2, _Ans = ok; }
		return (_Ans); }

	virtual result do_out(_Statype& _State,
		const _Elem *_First1, const _Elem *_Last1, const _Elem *& _Mid1,
		_Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
		{	
		_Mid1 = _First1, _Mid2 = _First2;
		result _Ans = _Mid1 == _Last1 ? ok : partial;
		int _Bytes;

		while (_Mid1 != _Last1 && _Mid2 != _Last2)
			if (((int)__ctype[520]) <= _Last2 - _Mid2)
				if ((_Bytes = _Wcrtomb(_Mid2, *_Mid1,
					&_State, &_Cvt)) <= 0)
					return (error);	
				else
					++_Mid1, _Mid2 += _Bytes, _Ans = ok;
			else
				{	
				_Byte _Buf[6];
				_Statype _Stsave = _State;

				if ((_Bytes = _Wcrtomb(_Buf, *_Mid1,
					&_State, &_Cvt)) <= 0)
					return (error);	
				else if (_Last2 - _Mid2 < _Bytes)
					{	
					_State = _Stsave;
					return (_Ans); }
				else
					{	
					memcpy(_Mid2, _Buf, _Bytes);
					++_Mid1, _Mid2 += _Bytes, _Ans = ok; }}
		return (_Ans); }

	virtual result do_unshift(_Statype& _State,
		_Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
		{	
		_Mid2 = _First2;
		result _Ans = ok;
		int _Bytes;
		_Byte _Buf[6];
		_Statype _Stsave = _State;

		if ((_Bytes = _Wcrtomb(_Buf, L'\0', &_State, &_Cvt)) <= 0)
			_Ans = error;	
		else if (_Last2 - _Mid2 < --_Bytes)
			{	
			_State = _Stsave;
			_Ans = partial; }
		else if (0 < _Bytes)
			{	
			memcpy(_Mid2, _Buf, _Bytes);
			_Mid2 += _Bytes; }
		return (_Ans); }

	virtual int do_length(_Statype& _State, const _Byte *_First1,
		const _Byte *_Last1, size_t _Count) const throw ()
		{	
		int _Wchars;
		const _Byte *_Mid1;

		for (_Wchars = 0, _Mid1 = _First1;
			(size_t)_Wchars < _Count && _Mid1 != _Last1; )
			{	
			int _Bytes;
			_Elem _Char;

			switch (_Bytes = _Mbrtowc(&_Char, _Mid1, _Last1 - _Mid1,
				&_State, &_Cvt))
				{	
			case -2:	
				return (_Wchars);

			case -1:	
				return (_Wchars);

			case 0:	
				_Bytes = strlen(_Mid1) + 1;
				

			default:	
				_Mid1 += _Bytes, ++_Wchars; }}
		return (_Wchars); }

	virtual bool do_always_noconv() const throw ()
		{	
		return (false); }

	virtual int do_max_length() const throw ()
		{	
		return (6); }

	virtual int do_encoding() const throw ()
		{	
		return (0); }

private:
	_Locinfo::_Cvtvec _Cvt;	
	};

		
template<class _Elem,
	class _Byte,
	class _Statype>
	class codecvt_byname
		: public codecvt<_Elem, _Byte, _Statype>
	{	
public:
	explicit codecvt_byname(const char *_Locname, size_t _Refs = 0)
		: codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Locname), _Refs)
		{}	

protected:
	virtual ~codecvt_byname()
		{}	
	};

		
struct ctype_base
	: public locale::facet
	{	
	enum
		{	
		alnum = 0x20|0x10|0x02|0x200, alpha = 0x10|0x02|0x200,
		cntrl = 0x80, digit = 0x20, graph = 0x20|0x10|0x08|0x02|0x200,
		lower = 0x10, print = 0x20|0x10|0x08|0x04|0x02|0x200|0x01,
		punct = 0x08, space = 0x40|0x04|0x100, upper = 0x02,
		xdigit = 0x01};
	typedef short mask;	

	ctype_base(size_t _Refs = 0)
		: locale::facet(_Refs)
		{}	

	~ctype_base()
		{}	
	};

		
template<class _Elem>
	class ctype
		: public ctype_base
	{	
public:
	typedef _Elem char_type;

	bool is(mask _Mask, _Elem _Char) const
		{	
		return (do_is(_Mask, _Char)); }

	const _Elem *is(const _Elem *_First, const _Elem *_Last,
		mask *_Ptr) const
		{	
		return (do_is(_First, _Last, _Ptr)); }

	const _Elem *scan_is(mask _Mask, const _Elem *_First,
		const _Elem *_Last) const
		{	
		return (do_scan_is(_Mask, _First, _Last)); }

	const _Elem *scan_not(mask _Mask, const _Elem *_First,
		const _Elem *_Last) const
		{	
		return (do_scan_not(_Mask, _First, _Last)); }

	_Elem tolower(_Elem _Char) const
		{	
		return (do_tolower(_Char)); }

	const _Elem *tolower(_Elem *_First, const _Elem *_Last) const
		{	
		return (do_tolower(_First, _Last)); }

	_Elem toupper(_Elem _Char) const
		{	
		return (do_toupper(_Char)); }

	const _Elem *toupper(_Elem *_First, const _Elem *_Last) const
		{	
		return (do_toupper(_First, _Last)); }

	_Elem widen(char _Byte) const
		{	
		return (do_widen(_Byte)); }

	const char *widen(const char *_First, const char *_Last,
		_Elem *_Ptr) const
		{	
		return (do_widen(_First, _Last, _Ptr)); }

	char narrow(_Elem _Char, char _Default = '\0') const
		{	
		return (do_narrow(_Char, _Default)); }

	const _Elem *narrow(const _Elem *_First, const _Elem *_Last,
		char _Default, char *_Ptr) const
		{	
		return (do_narrow(_First, _Last, _Default, _Ptr)); }

	static locale::id id;	

	explicit ctype(size_t _Refs = 0)
		: ctype_base(_Refs)
		{	
		_Init(_Locinfo()); }

	ctype(const _Locinfo& _Lobj, size_t _Refs = 0)
		: ctype_base(_Refs)
		{	
		_Init(_Lobj); }

	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{	
		if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new ctype<_Elem>;
		return (0); }

protected:
	virtual ~ctype()
		{	
		if (_Ctype._Delfl)
			free((void *)_Ctype._Table); }

protected:
	void _Init(const _Locinfo& _Lobj)
		{	
		_Ctype = _Lobj._Getctype(); }

	virtual bool do_is(mask _Mask, _Elem _Char) const
		{	
		return ((_Ctype._Table[(unsigned char)narrow(_Char)]
			& _Mask) != 0); }

	virtual const _Elem *do_is(const _Elem *_First, const _Elem *_Last,
		mask *_Ptr) const
		{	
		for (; _First != _Last; ++_First, ++_Ptr)
			*_Ptr = _Ctype._Table[(unsigned char)narrow(*_First)];
		return (_First); }

	virtual const _Elem *do_scan_is(mask _Mask, const _Elem *_First,
		const _Elem *_Last) const
		{	
		for (; _First != _Last && !is(_Mask, *_First); ++_First)
			;
		return (_First); }

	virtual const _Elem *do_scan_not(mask _Mask, const _Elem *_First,
		const _Elem *_Last) const
		{	
		for (; _First != _Last && is(_Mask, *_First); ++_First)
			;
		return (_First); }

	virtual _Elem do_tolower(_Elem _Char) const
		{	
		return (widen((char)_Tolower((unsigned char)narrow(_Char),
			&_Ctype))); }

	virtual const _Elem *do_tolower(_Elem *_First, const _Elem *_Last) const
		{	
		for (; _First != _Last; ++_First)
			*_First = widen((char)_Tolower((unsigned char)narrow(*_First),
				&_Ctype));
		return ((const _Elem *)_First); }

	virtual _Elem do_toupper(_Elem _Char) const
		{	
		return (widen((char)_Toupper((unsigned char)narrow(_Char),
			&_Ctype))); }

	virtual const _Elem *do_toupper(_Elem *_First, const _Elem *_Last) const
		{	
		for (; _First != _Last; ++_First)
			*_First = widen((char)_Toupper((unsigned char)narrow(*_First),
				&_Ctype));
		return ((const _Elem *)_First); }

	virtual _Elem do_widen(char _Byte) const
		{	
		return (_Widen(_Byte, (_Elem *)0)); }

	virtual const char *do_widen(const char *_First, const char *_Last,
		_Elem *_Ptr) const
		{	
		for (; _First != _Last; ++_First, ++_Ptr)
			*_Ptr = _Widen(*_First, (_Elem *)0);
		return (_First); }

	virtual char do_narrow(_Elem _Char, char) const
		{	
		return (_Narrow(static_cast<_Elem>(_Char))); }

	virtual const _Elem *do_narrow(const _Elem *_First, const _Elem *_Last,
		char, char *_Ptr) const
		{	
		for (; _First != _Last; ++_First, ++_Ptr)
			*_Ptr = _Narrow(static_cast<_Elem>(*_First));
		return (_First); }

private:
	_Locinfo::_Ctypevec _Ctype;	
	};

		
template<class _Elem>
	locale::id ctype<_Elem>::id;

		
template<> class ctype<char>
	: public ctype_base
	{	
	typedef ctype<char> _Myt;

public:
	typedef char _Elem;
	typedef _Elem char_type;

	bool is(mask _Mask, _Elem _Char) const
		{	
		return ((_Ctype._Table[(unsigned char)_Char] & _Mask) != 0); }

	const _Elem *is(const _Elem *_First, const _Elem *_Last,
		mask *_Ptr) const
		{	
		for (; _First != _Last; ++_First, ++_Ptr)
			*_Ptr = _Ctype._Table[(unsigned char)*_First];
		return (_First); }

	const _Elem *scan_is(mask _Mask, const _Elem *_First,
		const _Elem *_Last) const
		{	
		for (; _First != _Last && !is(_Mask, *_First); ++_First)
			;
		return (_First); }

	const _Elem *scan_not(mask _Mask, const _Elem *_First,
		const _Elem *_Last) const
		{	
		for (; _First != _Last && is(_Mask, *_First); ++_First)
			;
		return (_First); }

	_Elem tolower(_Elem _Char) const
		{	
		return (do_tolower(_Char)); }

	const _Elem *tolower(_Elem *_First, const _Elem *_Last) const
		{	
		return (do_tolower(_First, _Last)); }

	_Elem toupper(_Elem _Char) const
		{	
		return (do_toupper(_Char)); }

	const _Elem *toupper(_Elem *_First, const _Elem *_Last) const
		{	
		return (do_toupper(_First, _Last)); }

	_Elem widen(char _Byte) const
		{	
		return (do_widen(_Byte)); }

	const _Elem *widen(const char *_First, const char *_Last,
		_Elem *_Ptr) const
		{	
		return (do_widen(_First, _Last, _Ptr)); }

	_Elem narrow(_Elem _Char, char _Default = '\0') const
		{	
		return (do_narrow(_Char, _Default)); }

	const _Elem *narrow(const _Elem *_First, const _Elem *_Last,
		char _Default, char *_Ptr) const
		{	
		return (do_narrow(_First, _Last, _Default, _Ptr)); }

	static locale::id id;	

	explicit ctype(const mask *_Table = 0, bool _Deletetable = false,
		size_t _Refs = 0)
		: ctype_base(_Refs)
		{	
		_Init(_Locinfo());
		if (_Table != 0)
			{	
			_Tidy();
			_Ctype._Table = _Table;
			_Ctype._Delfl = _Deletetable; }}

	ctype(const _Locinfo& _Lobj, size_t _Refs = 0)
		: ctype_base(_Refs)
		{	
		_Init(_Lobj); }

	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{	
		if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new ctype<_Elem>;
		return (0); }

	static const size_t table_size;	

protected:
	virtual ~ctype()
		{	
		_Tidy(); }

protected:
	void _Init(const _Locinfo& _Lobj)
		{	
		_Ctype = _Lobj._Getctype(); }

	void _Tidy()
		{	
		if (_Ctype._Delfl)
			free((void *)_Ctype._Table); }

	virtual _Elem do_tolower(_Elem _Char) const
		{	
		return ((_Elem)_Tolower((unsigned char)_Char, &_Ctype)); }

	virtual const _Elem *do_tolower(_Elem *_First, const _Elem *_Last) const
		{	
		for (; _First != _Last; ++_First)
			*_First = (_Elem)_Tolower((unsigned char)*_First, &_Ctype);
		return ((const _Elem *)_First); }

	virtual _Elem do_toupper(_Elem _Char) const
		{	
		return ((_Elem)_Toupper((unsigned char)_Char, &_Ctype)); }

	virtual const _Elem *do_toupper(_Elem *_First, const _Elem *_Last) const
		{	
		for (; _First != _Last; ++_First)
			*_First = (_Elem)_Toupper((unsigned char)*_First, &_Ctype);
		return ((const _Elem *)_First); }

	virtual _Elem do_widen(char _Byte) const
		{	
		return (_Byte); }

	virtual const _Elem *do_widen(const char *_First, const char *_Last,
		_Elem *_Ptr) const
		{	
		memcpy(_Ptr, _First, _Last - _First);
		return (_Last); }

	virtual _Elem do_narrow(_Elem _Char, char) const
		{	
		return (_Char); }

	virtual const _Elem *do_narrow(const _Elem *_First, const _Elem *_Last,
		char, char *_Ptr) const
		{	
		memcpy(_Ptr, _First, _Last - _First);
		return (_Last); }

	const mask *table() const throw ()
		{	
		return (_Ctype._Table); }

	static const mask *classic_table() throw ()
		{	
		const _Myt& _Fac = use_facet<_Myt >(locale::classic());
		return (_Fac.table()); }

private:
	_Locinfo::_Ctypevec _Ctype;	
	};

		
template<class _Elem>
	class ctype_byname
	: public ctype<_Elem>
	{	
public:
	explicit ctype_byname(const char *_Locname, size_t _Refs = 0)
		: ctype<_Elem>(_Locinfo(_Locname), _Refs)
		{}	

protected:
	virtual ~ctype_byname()
		{}	
	};

}	





 
#line 5 "/usr/include/CC/xiosbase"

namespace std {

		
template<class _Dummy>
	class _Iosbase
	{	
public:
	enum _Fmtflags
		{	
		_Fmtmask = 0x7fff, _Fmtzero = 0};
	typedef _Fmtflags fmtflags;

	static const _Fmtflags skipws = (_Fmtflags)0x0001;
	static const _Fmtflags unitbuf = (_Fmtflags)0x0002;
	static const _Fmtflags uppercase = (_Fmtflags)0x0004;
	static const _Fmtflags showbase = (_Fmtflags)0x0008;
	static const _Fmtflags showpoint = (_Fmtflags)0x0010;
	static const _Fmtflags showpos = (_Fmtflags)0x0020;
	static const _Fmtflags left = (_Fmtflags)0x0040;
	static const _Fmtflags right = (_Fmtflags)0x0080;
	static const _Fmtflags internal = (_Fmtflags)0x0100;
	static const _Fmtflags dec = (_Fmtflags)0x0200;
	static const _Fmtflags oct = (_Fmtflags)0x0400;
	static const _Fmtflags hex = (_Fmtflags)0x0800;
	static const _Fmtflags scientific = (_Fmtflags)0x1000;
	static const _Fmtflags fixed = (_Fmtflags)0x2000;
	static const _Fmtflags boolalpha = (_Fmtflags)0x4000;
	static const _Fmtflags adjustfield = (_Fmtflags)0x01c0;
	static const _Fmtflags basefield = (_Fmtflags)0x0e00;
	static const _Fmtflags floatfield = (_Fmtflags)0x3000;

	enum _Iostate
		{	
		_Statmask = 0x7};
	typedef _Iostate iostate;

	static const _Iostate goodbit = (_Iostate)0x0;
	static const _Iostate eofbit = (_Iostate)0x1;
	static const _Iostate failbit = (_Iostate)0x2;
	static const _Iostate badbit = (_Iostate)0x4;

	enum _Openmode
		{	
		_Openmask = 0x3f};
	typedef _Openmode openmode;

	static const _Openmode in = (_Openmode)0x01;
	static const _Openmode out = (_Openmode)0x02;
	static const _Openmode ate = (_Openmode)0x04;
	static const _Openmode app = (_Openmode)0x08;
	static const _Openmode trunc = (_Openmode)0x10;
	static const _Openmode binary = (_Openmode)0x20;

	enum _Seekdir
		{	
		_Seekmask = 0x3};
	typedef _Seekdir seekdir;

	static const _Seekdir beg = (_Seekdir)0;
	static const _Seekdir cur = (_Seekdir)1;
	static const _Seekdir end = (_Seekdir)2;
	};

template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::skipws;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::unitbuf;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::uppercase;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::showbase;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::showpoint;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::showpos;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::left;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::right;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::internal;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::dec;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::oct;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::hex;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::scientific;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::fixed;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::boolalpha;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::adjustfield;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::basefield;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Fmtflags _Iosbase<_Dummy>::floatfield;

template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Iostate _Iosbase<_Dummy>::goodbit;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Iostate _Iosbase<_Dummy>::eofbit;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Iostate _Iosbase<_Dummy>::failbit;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Iostate _Iosbase<_Dummy>::badbit;

template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Openmode _Iosbase<_Dummy>::in;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Openmode _Iosbase<_Dummy>::out;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Openmode _Iosbase<_Dummy>::ate;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Openmode _Iosbase<_Dummy>::app;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Openmode _Iosbase<_Dummy>::trunc;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Openmode _Iosbase<_Dummy>::binary;

template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Seekdir _Iosbase<_Dummy>::beg;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Seekdir _Iosbase<_Dummy>::cur;
template<class _Dummy>
	const typename _Iosbase<_Dummy>::_Seekdir _Iosbase<_Dummy>::end;

		
class ios_base
	: public _Iosbase<int>
	{	
public:

	enum event
		{	
		erase_event, imbue_event, copyfmt_event};

	typedef void (*event_callback)(event, ios_base&, int);
	typedef unsigned int io_state, open_mode, seek_dir;

			
	class failure
		: public runtime_error
		{	
	public:
		explicit failure(const string &_Message)
			: runtime_error(_Message)
			{}	

		virtual ~failure()
    			throw () 
			{}	
	};

			
	class Init
		{	
	public:
		Init();	

		~Init();	

	private:
		static int _Init_cnt;	
		};

	ios_base& operator=(const ios_base& _Right)
		{	
		if (this != &_Right)
			{	
			_Mystate = _Right._Mystate;
			copyfmt(_Right); }
		return (*this); }

	operator void *() const
		{	
		return (fail() ? 0 : (void *)this); }

	bool operator!() const
		{	
		return (fail()); }

	void clear(iostate, bool);	

	void clear(iostate _State = goodbit)
		{	
		clear(_State, false); }

	void clear(io_state _State)
		{	
		clear((iostate)_State); }

	iostate rdstate() const
		{	
		return (_Mystate); }

	void setstate(iostate _State, bool _Exreraise)
		{	
		if (_State != goodbit)
			clear((iostate)((int)rdstate() | (int)_State), _Exreraise); }

	void setstate(iostate _State)
		{	
		if (_State != goodbit)
			clear((iostate)((int)rdstate() | (int)_State), false); }

	void setstate(io_state _State)
		{	
		setstate((iostate)_State); }

	bool good() const
		{	
		return (rdstate() == goodbit); }

	bool eof() const
		{	
		return ((int)rdstate() & (int)eofbit); }

	bool fail() const
		{	
		return (((int)rdstate()
			& ((int)badbit | (int)failbit)) != 0); }

	bool bad() const
		{	
		return (((int)rdstate() & (int)badbit) != 0); }

	iostate exceptions() const
		{	
		return (_Except); }

	void exceptions(iostate _Newexcept)
		{	
		_Except = (iostate)((int)_Newexcept & (int)_Statmask);
		clear(_Mystate); }

	void exceptions(io_state _State)
		{	
		exceptions((iostate)_State); }

	fmtflags flags() const
		{	
		return (_Fmtfl); }

	fmtflags flags(fmtflags _Newfmtflags)
		{	
		fmtflags _Oldfmtflags = _Fmtfl;
		_Fmtfl = (fmtflags)((int)_Newfmtflags & (int)_Fmtmask);
		return (_Oldfmtflags); }

	fmtflags setf(fmtflags _Newfmtflags)
		{	
		ios_base::fmtflags _Oldfmtflags = _Fmtfl;
		_Fmtfl = (fmtflags)((int)_Fmtfl
			| (int)_Newfmtflags & (int)_Fmtmask);
		return (_Oldfmtflags); }

	fmtflags setf(fmtflags _Newfmtflags, fmtflags _Mask)
		{	
		ios_base::fmtflags _Oldfmtflags = _Fmtfl;
		_Fmtfl = (fmtflags)(((int)_Fmtfl & (int)~_Mask)
			| ((int)_Newfmtflags & (int)_Mask & (int)_Fmtmask));
		return (_Oldfmtflags); }

	void unsetf(fmtflags _Mask)
		{	
		_Fmtfl = (fmtflags)((int)_Fmtfl & (int)~_Mask); }

	streamsize precision() const
		{	
		return (_Prec); }

	streamsize precision(int _Newprecision)
		{	
		streamsize _Oldprecision = _Prec;
		_Prec = _Newprecision;
		return (_Oldprecision); }

	streamsize width() const
		{	
		return (_Wide); }

	streamsize width(streamsize _Newwidth)
		{	
		streamsize _Oldwidth = _Wide;
		_Wide = _Newwidth;
		return (_Oldwidth); }

	locale getloc() const
		{	
		return (*_Ploc); }

	locale imbue(const locale&);	

	static int xalloc()
		{	
		return (_Index++); }

	long& iword(int _Idx)
		{	
		return (_Findarr(_Idx)._Lo); }

	void *& pword(int _Idx)
		{	
		return (_Findarr(_Idx)._Vp); }

	void register_callback(event_callback, int);	

	ios_base& copyfmt(const ios_base&);	

	virtual ~ios_base();	

	static bool sync_with_stdio(bool _Newsync = true)
		{	
		const bool _Oldsync = _Sync;
		_Sync = _Newsync;
		return (_Oldsync); }

	void _Addstd();	

protected:
	ios_base()
		: _Stdstr(0)
		{}	

	void _Init();	

private:
			
	struct _Iosarray
		{	
	public:
		_Iosarray(int _Idx, _Iosarray *_Link)
			: _Next(_Link), _Index(_Idx), _Lo(0), _Vp(0)
			{}	

		_Iosarray *_Next;	
		int _Index;	
		long _Lo;	
		void *_Vp;	
		};

			
	struct _Fnarray
		{	
		_Fnarray(int _Idx, event_callback _Pnew, _Fnarray *_Link)
			: _Next(_Link), _Index(_Idx), _Pfn(_Pnew)
			{}	

		_Fnarray *_Next;	
		int _Index;	
		event_callback _Pfn;	
		};

	void _Callfns(event);	

	_Iosarray& _Findarr(int);	

	void _Tidy();	

	iostate _Mystate;	
	iostate _Except;	
	fmtflags _Fmtfl;	
	int _Prec, _Wide;	
	_Iosarray *_Arr;	
	_Fnarray *_Calls;	
	locale *_Ploc;	
	size_t _Stdstr;	

	static int _Index;	
	static bool _Sync;	
	};

inline ios_base::_Fmtflags& operator&=(ios_base::_Fmtflags& _Left, ios_base::_Fmtflags _Right) { _Left = (ios_base::_Fmtflags)((int)_Left & (int)_Right); return _Left; } inline ios_base::_Fmtflags& operator|=(ios_base::_Fmtflags& _Left, ios_base::_Fmtflags _Right) { _Left = (ios_base::_Fmtflags)((int)_Left | (int)_Right); return _Left; } inline ios_base::_Fmtflags& operator^=(ios_base::_Fmtflags& _Left, ios_base::_Fmtflags _Right) { _Left = (ios_base::_Fmtflags)((int)_Left ^ (int)_Right); return _Left; } inline ios_base::_Fmtflags operator&(ios_base::_Fmtflags _Left, ios_base::_Fmtflags _Right) { return ((ios_base::_Fmtflags)((int)_Left & (int)_Right)); } inline ios_base::_Fmtflags operator|(ios_base::_Fmtflags _Left, ios_base::_Fmtflags _Right) { return ((ios_base::_Fmtflags)((int)_Left | (int)_Right)); } inline ios_base::_Fmtflags operator^(ios_base::_Fmtflags _Left, ios_base::_Fmtflags _Right) { return ((ios_base::_Fmtflags)((int)_Left ^ (int)_Right)); } inline ios_base::_Fmtflags operator~(ios_base::_Fmtflags _Left) { return ((ios_base::_Fmtflags)~(int)_Left); }
inline ios_base::_Iostate& operator&=(ios_base::_Iostate& _Left, ios_base::_Iostate _Right) { _Left = (ios_base::_Iostate)((int)_Left & (int)_Right); return _Left; } inline ios_base::_Iostate& operator|=(ios_base::_Iostate& _Left, ios_base::_Iostate _Right) { _Left = (ios_base::_Iostate)((int)_Left | (int)_Right); return _Left; } inline ios_base::_Iostate& operator^=(ios_base::_Iostate& _Left, ios_base::_Iostate _Right) { _Left = (ios_base::_Iostate)((int)_Left ^ (int)_Right); return _Left; } inline ios_base::_Iostate operator&(ios_base::_Iostate _Left, ios_base::_Iostate _Right) { return ((ios_base::_Iostate)((int)_Left & (int)_Right)); } inline ios_base::_Iostate operator|(ios_base::_Iostate _Left, ios_base::_Iostate _Right) { return ((ios_base::_Iostate)((int)_Left | (int)_Right)); } inline ios_base::_Iostate operator^(ios_base::_Iostate _Left, ios_base::_Iostate _Right) { return ((ios_base::_Iostate)((int)_Left ^ (int)_Right)); } inline ios_base::_Iostate operator~(ios_base::_Iostate _Left) { return ((ios_base::_Iostate)~(int)_Left); }
inline ios_base::_Openmode& operator&=(ios_base::_Openmode& _Left, ios_base::_Openmode _Right) { _Left = (ios_base::_Openmode)((int)_Left & (int)_Right); return _Left; } inline ios_base::_Openmode& operator|=(ios_base::_Openmode& _Left, ios_base::_Openmode _Right) { _Left = (ios_base::_Openmode)((int)_Left | (int)_Right); return _Left; } inline ios_base::_Openmode& operator^=(ios_base::_Openmode& _Left, ios_base::_Openmode _Right) { _Left = (ios_base::_Openmode)((int)_Left ^ (int)_Right); return _Left; } inline ios_base::_Openmode operator&(ios_base::_Openmode _Left, ios_base::_Openmode _Right) { return ((ios_base::_Openmode)((int)_Left & (int)_Right)); } inline ios_base::_Openmode operator|(ios_base::_Openmode _Left, ios_base::_Openmode _Right) { return ((ios_base::_Openmode)((int)_Left | (int)_Right)); } inline ios_base::_Openmode operator^(ios_base::_Openmode _Left, ios_base::_Openmode _Right) { return ((ios_base::_Openmode)((int)_Left ^ (int)_Right)); } inline ios_base::_Openmode operator~(ios_base::_Openmode _Left) { return ((ios_base::_Openmode)~(int)_Left); }
inline ios_base::_Seekdir& operator&=(ios_base::_Seekdir& _Left, ios_base::_Seekdir _Right) { _Left = (ios_base::_Seekdir)((int)_Left & (int)_Right); return _Left; } inline ios_base::_Seekdir& operator|=(ios_base::_Seekdir& _Left, ios_base::_Seekdir _Right) { _Left = (ios_base::_Seekdir)((int)_Left | (int)_Right); return _Left; } inline ios_base::_Seekdir& operator^=(ios_base::_Seekdir& _Left, ios_base::_Seekdir _Right) { _Left = (ios_base::_Seekdir)((int)_Left ^ (int)_Right); return _Left; } inline ios_base::_Seekdir operator&(ios_base::_Seekdir _Left, ios_base::_Seekdir _Right) { return ((ios_base::_Seekdir)((int)_Left & (int)_Right)); } inline ios_base::_Seekdir operator|(ios_base::_Seekdir _Left, ios_base::_Seekdir _Right) { return ((ios_base::_Seekdir)((int)_Left | (int)_Right)); } inline ios_base::_Seekdir operator^(ios_base::_Seekdir _Left, ios_base::_Seekdir _Right) { return ((ios_base::_Seekdir)((int)_Left ^ (int)_Right)); } inline ios_base::_Seekdir operator~(ios_base::_Seekdir _Left) { return ((ios_base::_Seekdir)~(int)_Left); }

}	





 
#line 5 "/usr/include/CC/streambuf"

namespace std {

		
template<class _Elem, class _Traits>
	class basic_streambuf
	{	
	basic_streambuf(const basic_streambuf<_Elem, _Traits>&);	

	basic_streambuf<_Elem, _Traits>&
		operator=(const basic_streambuf<_Elem, _Traits>&);	

protected:
	basic_streambuf()
		: _Plocale(new locale)
		{	
		_Init(); }

	basic_streambuf(_Uninitialized)
		{}	

public:
	typedef basic_streambuf<_Elem, _Traits> _Myt;
	typedef _Elem char_type;
	typedef _Traits traits_type;

	virtual ~basic_streambuf()
		{	
		delete _Plocale; }

	typedef typename _Traits::int_type int_type;
	typedef typename _Traits::pos_type pos_type;
	typedef typename _Traits::off_type off_type;

	pos_type pubseekoff(off_type _Off, ios_base::seekdir _Way,
		ios_base::openmode _Mode = ios_base::in | ios_base::out)
		{	
		return (seekoff(_Off, _Way, _Mode)); }

	pos_type pubseekoff(off_type _Off, ios_base::seek_dir _Way,
		ios_base::open_mode _Mode)
		{	
		return (pubseekoff(_Off, (ios_base::seekdir)_Way,
			(ios_base::openmode)_Mode)); }

	pos_type pubseekpos(pos_type _Pos,
		ios_base::openmode _Mode = ios_base::in | ios_base::out)
		{	
		return (seekpos(_Pos, _Mode)); }

	pos_type pubseekpos(pos_type _Pos, ios_base::open_mode _Mode)
		{	
		return (seekpos(_Pos, (ios_base::openmode)_Mode)); }

	_Myt *pubsetbuf(_Elem *_Buffer, streamsize _Count)
		{	
		return (setbuf(_Buffer, _Count)); }

	locale pubimbue(const locale &_Newlocale)
		{	
		locale _Oldlocale = *_Plocale;
		imbue(_Newlocale);
		*_Plocale = _Newlocale;
		return (_Oldlocale); }

	locale getloc()
		{	
		return (*_Plocale); }

	streamsize in_avail()
		{	
		return (gptr() != 0 && gptr() < egptr()
			? egptr() - gptr() : showmanyc()); }

	int pubsync()
		{	
		return (sync()); }

	int_type sbumpc()
		{	
		return (gptr() != 0 && gptr() < egptr()
			? _Traits::to_int_type(*_Gninc()) : uflow()); }

	int_type sgetc()
		{	
		return (gptr() != 0 && gptr() < egptr()
			? _Traits::to_int_type(*gptr()) : underflow()); }

	streamsize sgetn(_Elem *_Ptr, streamsize _Count)
		{	
		return (xsgetn(_Ptr, _Count)); }

	int_type snextc()
		{	
		return (_Traits::eq_int_type(_Traits::eof(), sbumpc())
			? _Traits::eof() : sgetc()); }

	int_type sputbackc(_Elem _Char)
		{	
		return (gptr() != 0 && eback() < gptr()
			&& _Traits::eq(_Char, gptr()[-1])
			? _Traits::to_int_type(*_Gndec())
			: pbackfail(_Traits::to_int_type(_Char))); }

	void stossc()
		{	
		if (gptr() != 0 && gptr() < egptr())
			_Gninc();
		else
			uflow(); }

	int_type sungetc()
		{	
		return (gptr() != 0 && eback() < gptr()
			? _Traits::to_int_type(*_Gndec()) : pbackfail()); }

	int_type sputc(_Elem _Char)
		{	
		return (pptr() != 0 && pptr() < epptr()
			? _Traits::to_int_type(*_Pninc() = _Char)
			: overflow(_Traits::to_int_type(_Char))); }

	streamsize sputn(const _Elem *_Ptr, streamsize _Count)
		{	
		return (xsputn(_Ptr, _Count)); }

protected:
	_Elem *eback() const
		{	
		return (*_IGfirst); }

	_Elem *gptr() const
		{	
		return (*_IGnext); }

	_Elem *pbase() const
		{	
		return (*_IPfirst); }

	_Elem *pptr() const
		{	
		return (*_IPnext); }

	_Elem *egptr() const
		{	
		return (*_IGnext + *_IGcount); }

	void gbump(int _Off)
		{	
		*_IGcount -= _Off;
		*_IGnext += _Off; }

	void setg(_Elem *_First, _Elem *_Next, _Elem *_Last)
		{	
		*_IGfirst = _First;
		*_IGnext = _Next;
		*_IGcount = (int)(_Last - _Next); }

	_Elem *epptr() const
		{	
		return (*_IPnext + *_IPcount); }

	_Elem *_Gndec()
		{	
		++*_IGcount;
		return (--*_IGnext); }

	_Elem *_Gninc()
		{	
		--*_IGcount;
		return ((*_IGnext)++); }

	void pbump(int _Off)
		{	
		*_IPcount -= _Off;
		*_IPnext += _Off; }

	void setp(_Elem *_First, _Elem *_Last)
		{	
		*_IPfirst = _First;
		*_IPnext = _First;
		*_IPcount = (int)(_Last - _First); }

	void setp(_Elem *_First, _Elem *_Next, _Elem *_Last)
		{	
		*_IPfirst = _First;
		*_IPnext = _Next;
		*_IPcount = (int)(_Last - _Next); }

	_Elem *_Pninc()
		{	
		--*_IPcount;
		return ((*_IPnext)++); }

	void _Init()
		{	
		_IGfirst = &_Gfirst, _IPfirst = &_Pfirst;
		_IGnext = &_Gnext, _IPnext = &_Pnext;
		_IGcount = &_Gcount, _IPcount = &_Pcount;
		setp(0, 0), setg(0, 0, 0); }

	void _Init(_Elem **_Gf, _Elem **_Gn, int *_Gc,
		_Elem **_Pf, _Elem **_Pn, int *_Pc)
		{	
		_IGfirst = _Gf, _IPfirst = _Pf;
		_IGnext = _Gn, _IPnext = _Pn;
		_IGcount = _Gc, _IPcount = _Pc; }

	virtual int_type overflow(int_type = _Traits::eof())
		{	
		return (_Traits::eof()); }

	virtual int_type pbackfail(int_type = _Traits::eof())
		{	
		return (_Traits::eof()); }

	virtual streamsize showmanyc()
		{	
		return (0); }

	virtual int_type underflow()
		{	
		return (_Traits::eof()); }

	virtual int_type uflow()
		{	
		return (_Traits::eq_int_type(_Traits::eof(), underflow())
			? _Traits::eof() : _Traits::to_int_type(*_Gninc())); }

	virtual streamsize xsgetn(_Elem * _Ptr, streamsize _Count)
		{	
		int_type _Meta;
		streamsize _Size, _Copied;

		for (_Copied = 0; 0 < _Count; )
			if (gptr() != 0 && 0 < (_Size = egptr() - gptr()))
				{	
				if (_Count < _Size)
					_Size = _Count;
				_Traits::copy(_Ptr, gptr(), _Size);
				_Ptr += _Size;
				_Copied += _Size;
				_Count -= _Size;
				gbump(_Size); }
			else if (_Traits::eq_int_type(_Traits::eof(), _Meta = uflow()))
				break;	
			else
				{	
				*_Ptr++ = _Traits::to_char_type(_Meta);
				++_Copied;
				--_Count; }

		return (_Copied); }

	virtual streamsize xsputn(const _Elem *_Ptr, streamsize _Count)
		{	
		streamsize _Size, _Copied;

		for (_Copied = 0; 0 < _Count; )
			if (pptr() != 0 && 0 < (_Size = epptr() - pptr()))
				{	
				if (_Count < _Size)
					_Size = _Count;
				_Traits::copy(pptr(), _Ptr, _Size);
				_Ptr += _Size;
				_Copied += _Size;
				_Count -= _Size;
				pbump(_Size); }
			else if (_Traits::eq_int_type(_Traits::eof(),
				overflow(_Traits::to_int_type(*_Ptr))))
				break;	
			else
				{	
				++_Ptr;
				++_Copied;
				--_Count; }

		return (_Copied); }

	virtual pos_type seekoff(off_type, ios_base::seekdir,
		ios_base::openmode = ios_base::in | ios_base::out)
		{	
		return (streampos(_BADOFF)); }

	virtual pos_type seekpos(pos_type,
		ios_base::openmode = ios_base::in | ios_base::out)
		{	
		return (streampos(_BADOFF)); }

	virtual _Myt *setbuf(_Elem *, streamsize)
		{	
		return (this); }

	virtual int sync()
		{	
		return (0); }

	virtual void imbue(const locale&)
		{}	

private:
	_Elem *_Gfirst;	
	_Elem *_Pfirst;	
	_Elem **_IGfirst;	
	_Elem **_IPfirst;	
	_Elem *_Gnext;	
	_Elem *_Pnext;	
	_Elem **_IGnext;	
	_Elem **_IPnext;	
	int _Gcount;	
	int _Pcount;	
	int *_IGcount;	
	int *_IPcount;	
	locale *_Plocale;	
	};

}	





 
#line 9 "/usr/include/CC/xlocnum"

namespace std {

		
template<class _Elem>
	class numpunct
		: public locale::facet
	{	
public:
	typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> >
		string_type;
	typedef _Elem char_type;

	static locale::id id;	

	_Elem decimal_point() const
		{	
		return (do_decimal_point()); }

	_Elem thousands_sep() const
		{	
		return (do_thousands_sep()); }

	string grouping() const
		{	
		return (do_grouping()); }

	string_type falsename() const
		{	
		return (do_falsename()); }

	string_type truename() const
		{	
		return (do_truename()); }

	explicit numpunct(size_t _Refs = 0)
		: locale::facet(_Refs)
		{	
		_Init(_Locinfo()); }

	numpunct(const _Locinfo& _Lobj, size_t _Refs = 0)
		: locale::facet(_Refs)
		{	
		_Init(_Lobj); }

	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{	
		if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new numpunct<_Elem>;
		return (1); }

protected:
	virtual ~numpunct()
		{	
		delete[] (void *)_Grouping;
		delete[] (void *)_Falsename;
		delete[] (void *)_Truename; }

protected:
	void _Init(const _Locinfo& _Lobj)
		{	
		const lconv *_Ptr = _Lobj._Getlconv();
		_Dp = _Widen(_Ptr->decimal_point[0], (_Elem *)0);
		_Kseparator = _Widen(_Ptr->thousands_sep[0], (_Elem *)0);
		_Grouping = _Maklocstr(_Ptr->grouping, (char *)0);
		_Falsename = _Maklocstr(_Lobj . _Getfalse(), (_Elem *)0);
		_Truename = _Maklocstr(_Lobj . _Gettrue(), (_Elem *)0); }

	virtual _Elem do_decimal_point() const
		{	
		return (_Dp); }

	virtual _Elem do_thousands_sep() const
		{	
		return (_Kseparator); }

	virtual string do_grouping() const
		{	
		return (string(_Grouping)); }

	virtual string_type do_falsename() const
		{	
		return (string_type(_Falsename)); }

	virtual string_type do_truename() const
		{	
		return (string_type(_Truename)); }

private:
	const char *_Grouping;	
	_Elem _Dp;	
	_Elem _Kseparator;	
	const _Elem *_Falsename;	
	const _Elem *_Truename;	
	};

typedef numpunct<char> _Npc;
typedef numpunct<wchar_t> _Npwc;

		
template<class _Elem>
	class numpunct_byname
		: public numpunct<_Elem>
	{	
public:
	explicit numpunct_byname(const char *_Locname, size_t _Refs = 0)
		: numpunct<_Elem>(_Locinfo(_Locname), _Refs)
		{}	

protected:
	virtual ~numpunct_byname()
		{}	
	};

		
template<class _Elem>
	locale::id numpunct<_Elem>::id;



		
template<class _Elem,
	class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> > >
	class num_get
		: public locale::facet
	{	
public:
	typedef numpunct<_Elem> _Mypunct;
	typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> >
		_Mystr;

	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{	
		if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new num_get<_Elem, _InIt>;
		return (1); }

	static locale::id id;	

protected:
	virtual ~num_get()
		{}	

protected:
	void _Init(const _Locinfo&)
		{}	

public:
	explicit num_get(size_t _Refs = 0)
		: locale::facet(_Refs)
		{	
		_Init(_Locinfo()); }

	num_get(const _Locinfo& _Lobj, size_t _Refs = 0)
		: locale::facet(_Refs)
		{	
		_Init(_Lobj); }

	typedef _Elem char_type;
	typedef _InIt iter_type;

	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, _Bool& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }

	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, unsigned short& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }

	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, unsigned int& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }

	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, long& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }

	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, unsigned long& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }


	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, long long& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }

	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, unsigned long long& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }


	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, float& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }

	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, double& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }

	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, long double& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }

	_InIt get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, void *& _Val) const
		{	
		return (do_get(_First, _Last, _Ios, _State, _Val)); }

protected:
	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, _Bool& _Val) const
		{	
		int _Ans = -1;	

		if (_Ios.flags() & ios_base::boolalpha)
			{	
			const _Mypunct& _Fac = use_facet<_Mypunct >(_Ios . getloc());
			_Mystr _Str((typename _Mystr::size_type)1, (char_type)0);
			_Str += _Fac.falsename();
			_Str += (char_type)0;
			_Str += _Fac.truename();	
			_Ans = _Getloctxt(_First, _Last, (size_t)2, _Str.c_str()); }
		else
			{	
			char _Ac[32], *_Ep;
			errno = 0;
			const unsigned long _Ulo = strtoul(_Ac, &_Ep,
				_Getifld(_Ac, _First, _Last, _Ios.flags(), _Ios.getloc()));
			if (_Ep != _Ac && errno == 0 && _Ulo <= 1)
				_Ans = _Ulo; }

		if (_First == _Last)
			_State |= ios_base::eofbit;
		if (_Ans < 0)
			_State |= ios_base::failbit;
		else
			_Val = _Ans != 0;	
		return (_First); }

	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, unsigned short& _Val) const
		{	
		char _Ac[32], *_Ep;
		errno = 0;
		int _Base = _Getifld(_Ac, _First, _Last,
			_Ios.flags(), _Ios.getloc());	
		char *_Ptr = _Ac[0] == '-' ? _Ac + 1 : _Ac;	
		const unsigned long _Ans = strtoul(_Ptr, &_Ep, _Base);	

		if (_First == _Last)
			_State |= ios_base::eofbit;
		if (_Ep == _Ptr || errno != 0 || 65535 < _Ans)
			_State |= ios_base::failbit;
		else
			_Val = (unsigned short)(_Ac[0] == '-'
				? 0 -_Ans : _Ans);	
		return (_First); }

	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, unsigned int& _Val) const
		{	
		char _Ac[32], *_Ep;
		errno = 0;
		int _Base = _Getifld(_Ac, _First, _Last,
			_Ios.flags(), _Ios.getloc());	
		char *_Ptr = _Ac[0] == '-' ? _Ac + 1 : _Ac;	
		const unsigned long _Ans = strtoul(_Ptr, &_Ep, _Base);	

		if (_First == _Last)
			_State |= ios_base::eofbit;
		if (_Ep == _Ptr || errno != 0 || 0xffffffff < _Ans)
			_State |= ios_base::failbit;
		else
			_Val = _Ac[0] == '-' ? 0 -_Ans : _Ans;	
		return (_First); }

	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, long& _Val) const
		{	
		char _Ac[32], *_Ep;
		errno = 0;
		const long _Ans = strtol(_Ac, &_Ep,
			_Getifld(_Ac, _First, _Last,
				_Ios.flags(), _Ios.getloc()));	

		if (_First == _Last)
			_State |= ios_base::eofbit;
		if (_Ep == _Ac || errno != 0)
			_State |= ios_base::failbit;
		else
			_Val = _Ans;	
		return (_First); }

	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, unsigned long& _Val) const
		{	
		char _Ac[32], *_Ep;
		errno = 0;
		const unsigned long _Ans = strtoul(_Ac, &_Ep,
			_Getifld(_Ac, _First, _Last,
				_Ios.flags(), _Ios.getloc()));	

		if (_First == _Last)
			_State |= ios_base::eofbit;
		if (_Ep == _Ac || errno != 0)
			_State |= ios_base::failbit;
		else
			_Val = _Ans;	
		return (_First); }


	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, long long& _Val) const
		{	
		char _Ac[32];
		errno = 0;
		_Getifld(_Ac, _First, _Last,
			_Ios.flags(), _Ios.getloc());	
		const long long _Ans = strtoll(_Ac, 0, 10);	

		if (_First == _Last)
			_State |= ios_base::eofbit;
		if (errno != 0)
			_State |= ios_base::failbit;
		else
			_Val = _Ans;	
		return (_First); }

	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, unsigned long long& _Val) const
		{	
		char _Ac[32];
		errno = 0;
		_Getifld(_Ac, _First, _Last,
			_Ios.flags(), _Ios.getloc());	
		const unsigned long long _Ans = strtoull(_Ac, 0, 10);	

		if (_First == _Last)
			_State |= ios_base::eofbit;
		if (errno != 0)
			_State |= ios_base::failbit;
		else
			_Val = _Ans;	
		return (_First); }


	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, float& _Val) const
		{	
		char _Ac[8 + 36 + 16], *_Ep;
		errno = 0;
		const float _Ans = _Stof(_Ac, &_Ep,
			_Getffld(_Ac, _First, _Last,
				_Ios.getloc()));	

		if (_First == _Last)
			_State |= ios_base::eofbit;
		if (_Ep == _Ac || errno != 0)
			_State |= ios_base::failbit;
		else
			_Val = _Ans;	
		return (_First); }

	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, double& _Val) const
		{	
		char _Ac[8 + 36 + 16], *_Ep;
		errno = 0;
		const double _Ans = _Stod(_Ac, &_Ep,
			_Getffld(_Ac, _First, _Last,
				_Ios.getloc()));	

		if (_First == _Last)
			_State |= ios_base::eofbit;
		if (_Ep == _Ac || errno != 0)
			_State |= ios_base::failbit;
		else
			_Val = _Ans;	
		return (_First); }

	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, long double& _Val) const
		{	
		char _Ac[8 + 36 + 16], *_Ep;
		errno = 0;
		const long double _Ans = _Stold(_Ac, &_Ep,
			_Getffld(_Ac, _First, _Last,
				_Ios.getloc()));	

		if (_First == _Last)
			_State |= ios_base::eofbit;
		if (_Ep == _Ac || errno != 0)
			_State |= ios_base::failbit;
		else
			_Val = _Ans;	
		return (_First); }

	virtual _InIt do_get(_InIt _First, _InIt _Last, ios_base& _Ios,
		ios_base::iostate& _State, void *& _Val) const
		{	
		union _Pvlo
			{	
			void *_Pv;
			unsigned long _Lo[1 +
				(sizeof (void *) - 1) / sizeof (unsigned long)];
			} _Union;
		const int _NL = sizeof (_Union._Lo) / sizeof (unsigned long);
		for (int _Off = 0; ; ++_First)
			{	
			char _Ac[32], *_Ep;
			errno = 0;
			_Union._Lo[_Off] = strtoul(_Ac, &_Ep,
				_Getifld(_Ac, _First, _Last, ios_base::hex,
					_Ios.getloc()));	

			if (_First == _Last)
				_State |= ios_base::eofbit;
			if (_Ep == _Ac || errno != 0)
				{	
				_State |= ios_base::failbit;
				break; }

			if (_NL <= ++_Off)
				break;	
			if (_First == _Last || *_First != _Widen(':', (_Elem *)0))
				{	
				_State |= ios_base::failbit;
				break; }}

		if (!(_State & ios_base::failbit))
			_Val = _Union._Pv;	
		return (_First); }

private:
	static int _Getifld(char *_Ac, _InIt& _First, _InIt& _Last,
		ios_base::fmtflags _Basefield, const locale& _Loc)
		{	
		const _Elem _E0 = _Widen('0', (_Elem *)0);
		const _Mypunct& _Fac = use_facet<_Mypunct >(_Loc);
		const string _Grouping = _Fac.grouping();
		const _Elem _Kseparator = _Fac.thousands_sep();
		char *_Ptr = _Ac;

		if (_First == _Last)
			;	
		else if (*_First == _Widen('+', (_Elem *)0))
			*_Ptr++ = '+', ++_First;	
		else if (*_First == _Widen('-', (_Elem *)0))
			*_Ptr++ = '-', ++_First;	

		_Basefield &= ios_base::basefield;
		int _Base = _Basefield == ios_base::oct ? 8
			: _Basefield == ios_base::hex ? 16
			: _Basefield == ios_base::_Fmtzero ? 0 : 10;

		bool _Seendigit = false;	
		bool _Nonzero = false;	

		if (_First != _Last && *_First == _E0)
			{	
			_Seendigit = true, ++_First;
			if (_First != _Last && (*_First == _Widen('x', (_Elem *)0)
					|| *_First == _Widen('X', (_Elem *)0))
				&& (_Base == 0 || _Base == 16))
				_Base = 16, _Seendigit = false, ++_First;
			else if (_Base == 0)
				_Base = 8; }

		int _Dlen = _Base == 0 || _Base == 10 ? 10
			: _Base == 8 ? 8 : 16 + 6;
		string _Groups((size_t)1, (char)_Seendigit);
		size_t _Group = 0;

		for (char *const _Pe = &_Ac[32 - 1];
			_First != _Last; ++_First)
			if (memchr("0123456789abcdefABCDEF",
				*_Ptr = _Narrow(static_cast<_Elem>(*_First)), _Dlen) != 0)
				{	
				if ((_Nonzero || *_Ptr != '0') && _Ptr < _Pe)
					++_Ptr, _Nonzero = true;
				_Seendigit = true;
				if (_Groups[_Group] != 127)
					++_Groups[_Group]; }
			else if (_Groups[_Group] == '\0'
				|| _Kseparator == (_Elem)0
				|| *_First != _Kseparator)
				break;	
			else
				{	
				_Groups.append((string::size_type)1, '\0');
				++_Group; }

		if (_Group == 0)
			;	
		else if ('\0' < _Groups[_Group])
			++_Group;	
		else
			_Seendigit = false;	

		for (const char *_Pg = _Grouping.c_str(); _Seendigit && 0 < _Group; )
			if (*_Pg == 127)
				break;	
			else if (0 < --_Group && *_Pg != _Groups[_Group]
				|| 0 == _Group && *_Pg < _Groups[_Group])
				_Seendigit = false;	
			else if ('\0' < _Pg[1])
				++_Pg;	

		if (_Seendigit && !_Nonzero)
			*_Ptr++ = '0';	
		else if (!_Seendigit)
			_Ptr = _Ac;	
		*_Ptr = '\0';
		return (_Base);
		}

	static int _Getffld(char *_Ac, _InIt& _First, _InIt &_Last,
		const locale& _Loc)
		{	
		const _Elem _E0 = _Widen('0', (_Elem *)0);
		const _Mypunct& _Fac = use_facet<_Mypunct >(_Loc);
		char *_Ptr = _Ac;

		if (_First == _Last)
			;	
		else if (*_First == _Widen('+', (_Elem *)0))
			*_Ptr++ = '+', ++_First;	
		else if (*_First == _Widen('-', (_Elem *)0))
			*_Ptr++ = '-', ++_First;	

		bool _Seendigit = false;	
		for (; _First != _Last && *_First == _E0; _Seendigit = true, ++_First)
			;	
		if (_Seendigit)
			*_Ptr++ = '0';	

		int _Significant = 0;	
		int _Pten = 0;	

		for (; _First != _Last
			&& (::isdigit)(*_Ptr = _Narrow(static_cast<_Elem>(*_First)));
				_Seendigit = true, ++_First)
			if (_Significant < 36)
				++_Ptr, ++_Significant;	
			else
				++_Pten;	

		if (_First != _Last && *_First == _Fac.decimal_point())
			*_Ptr++ = localeconv()->decimal_point[0], ++_First;	

		if (_Significant == 0)
			{	
			for (; _First != _Last && *_First == _E0;
				_Seendigit = true, ++_First)
				--_Pten;	
			if (_Pten < 0)
				*_Ptr++ = '0', ++_Pten; }	

		for (; _First != _Last
			&& (::isdigit)(*_Ptr = _Narrow(static_cast<_Elem>(*_First)));
				_Seendigit = true, ++_First)
			if (_Significant < 36)
				++_Ptr, ++_Significant;	

		if (_Seendigit && _First != _Last
			&& (*_First == _Widen('e', (_Elem *)0)
				|| *_First == _Widen('E', (_Elem *)0)))
			{	
			*_Ptr++ = 'e', ++_First;
			_Seendigit = false, _Significant = 0;

			if (_First == _Last)
				;	
			else if (*_First == _Widen('+', (_Elem *)0))
				*_Ptr++ = '+', ++_First;	
			else if (*_First == _Widen('-', (_Elem *)0))
				*_Ptr++ = '-', ++_First;	
			for (; _First != _Last && *_First == _E0; )
				_Seendigit = true, ++_First;	
			if (_Seendigit)
				*_Ptr++ = '0';	
			for (; _First != _Last
				&& (::isdigit)(*_Ptr = _Narrow(static_cast<_Elem>(*_First)));
				_Seendigit = true, ++_First)
				if (_Significant < 8)
					++_Ptr, ++_Significant; }	

		if (!_Seendigit)
			_Ptr = _Ac;	
		*_Ptr = '\0';
		return (_Pten);
		};
	};

		
template<class _Elem,
	class _InIt>
	locale::id num_get<_Elem, _InIt>::id;

		
template<class _Elem,
	class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem> > >
	class num_put
		: public locale::facet
	{	
public:
	typedef numpunct<_Elem> _Mypunct;
	typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> >
		_Mystr;

	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{	
		if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new num_put<_Elem, _OutIt>;
		return (1); }

	static locale::id id;	

protected:
	virtual ~num_put()
		{}	

protected:
	void _Init(const _Locinfo&)
		{}	

public:
	explicit num_put(size_t _Refs = 0)
		: locale::facet(_Refs)
		{	
		_Init(_Locinfo()); }

	num_put(const _Locinfo& _Lobj, size_t _Refs = 0)
		: locale::facet(_Refs)
		{	
		_Init(_Lobj); }

	typedef _Elem char_type;
	typedef _OutIt iter_type;

	_OutIt put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		_Bool _Val) const
		{	
		return (do_put(_Dest, _Ios, _Fill, _Val)); }

	_OutIt put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		long _Val) const
		{	
		return (do_put(_Dest, _Ios, _Fill, _Val)); }

	_OutIt put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		unsigned long _Val) const
		{	
		return (do_put(_Dest, _Ios, _Fill, _Val)); }


	_OutIt put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		long long _Val) const
		{	
		return (do_put(_Dest, _Ios, _Fill, _Val)); }

	_OutIt put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		unsigned long long _Val) const
		{	
		return (do_put(_Dest, _Ios, _Fill, _Val)); }


	_OutIt put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		double _Val) const
		{	
		return (do_put(_Dest, _Ios, _Fill, _Val)); }

	_OutIt put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		long double _Val) const
		{	
		return (do_put(_Dest, _Ios, _Fill, _Val)); }

	_OutIt put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		const void *_Val) const
		{	
		return (do_put(_Dest, _Ios, _Fill, _Val)); }

protected:
	virtual _OutIt do_put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		_Bool _Val) const
		{	
		if (!(_Ios.flags() & ios_base::boolalpha))
			return (do_put(_Dest, _Ios, _Fill, (long)_Val));
		else
			{	
			const _Mypunct& _Fac = use_facet<_Mypunct >(_Ios . getloc());
			const _Mystr _Str(_Val ? _Fac.truename() : _Fac.falsename());

			size_t _Fillcount = _Ios.width() <= 0
				|| (size_t)_Ios.width() <= _Str.size()
					? 0 : (size_t)_Ios.width() - _Str.size();

			if ((_Ios.flags() & ios_base::adjustfield) != ios_base::left)
				{	
				_Dest = _Rep(_Dest, _Fill, _Fillcount);
				_Fillcount = 0; }
			_Dest = _Put(_Dest, _Str.c_str(), _Str.size());	
			_Ios.width(0);
			return (_Rep(_Dest, _Fill, _Fillcount)); }}	

	virtual _OutIt do_put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		long _Val) const
		{	
		char _Buf[2 * 32], _Fmt[6];
		return (_Iput(_Dest, _Ios, _Fill, _Buf,
			sprintf(_Buf, _Ifmt(_Fmt, "ld", _Ios.flags()), _Val))); }

	virtual _OutIt do_put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		unsigned long _Val) const
		{	
		char _Buf[2 * 32], _Fmt[6];
		return (_Iput(_Dest, _Ios, _Fill, _Buf,
			sprintf(_Buf, _Ifmt(_Fmt, "lu", _Ios.flags()), _Val))); }


	virtual _OutIt do_put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		long long _Val) const
		{	
		char _Buf[2 * 32], _Fmt[6];
		return (_Iput(_Dest, _Ios, _Fill, _Buf,
			sprintf(_Buf, _Ifmt(_Fmt, "Ld", _Ios.flags()), _Val))); }

	virtual _OutIt do_put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		unsigned long long _Val) const
		{	
		char _Buf[2 * 32], _Fmt[6];
		return (_Iput(_Dest, _Ios, _Fill, _Buf,
			sprintf(_Buf, _Ifmt(_Fmt, "Lu", _Ios.flags()), _Val))); }


	virtual _OutIt do_put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		double _Val) const
		{	
		char _Buf[8 + 36 + 64], _Fmt[8];
		streamsize _Precision = _Ios.precision() <= 0
			&& !(_Ios.flags() & ios_base::fixed)
				? 6 : _Ios.precision();	
		int _Significance = 36 < _Precision
			? 36 : _Precision;	
		_Precision -= _Significance;
		size_t _Beforepoint = 0;	
		size_t _Afterpoint = 0;	

		if ((_Ios.flags() & ios_base::floatfield) == ios_base::fixed)
			{	
			bool _Signed = _Val < 0;
			if (_Signed)
				_Val = -_Val;

			for (; 1e35 <= _Val && _Beforepoint < 5000; _Beforepoint += 10)
				_Val /= 1e10;	

			if (0 < _Val)
				for (; 10 <= _Precision && _Val <= 1e-35
					&& _Afterpoint < 5000; _Afterpoint += 10)
					{	
					_Val *= 1e10;
					_Precision -= 10; }

			if (_Signed)
				_Val = -_Val; }

		return (_Fput(_Dest, _Ios, _Fill, _Buf,
			_Beforepoint, _Afterpoint, _Precision,
				sprintf(_Buf, _Ffmt(_Fmt, 0, _Ios.flags()),
					_Significance, _Val))); }	

	virtual _OutIt do_put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		long double _Val) const
		{	
		char _Buf[8 + 36 + 64], _Fmt[8];
		streamsize _Precision = _Ios.precision() <= 0
			&& !(_Ios.flags() & ios_base::fixed)
				? 6 : _Ios.precision();	
		int _Significance = 36 < _Precision
			? 36 : _Precision;	
		_Precision -= _Significance;
		size_t _Beforepoint = 0;	
		size_t _Afterpoint = 0;	

		if ((_Ios.flags() & ios_base::floatfield) == ios_base::fixed)
			{	
			bool _Signed = _Val < 0;
			if (_Signed)
				_Val = -_Val;

			for (; 1e35 <= _Val && _Beforepoint < 5000; _Beforepoint += 10)
				_Val /= 1e10;	

			if (0 < _Val)
				for (; 10 <= _Precision && _Val <= 1e-35
					&& _Afterpoint < 5000; _Afterpoint += 10)
					{	
					_Val *= 1e10;
					_Precision -= 10; }

			if (_Signed)
				_Val = -_Val; }

		return (_Fput(_Dest, _Ios, _Fill, _Buf,
			_Beforepoint, _Afterpoint, _Precision,
				sprintf(_Buf, _Ffmt(_Fmt, 'L', _Ios.flags()),
					_Significance, _Val))); }	

	virtual _OutIt do_put(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		const void *_Val) const
		{	
		const int _NL = 1
			+ (sizeof (void *) - 1) / sizeof (unsigned long);
		char _Buf[(_NL + 1) * (32 + 1)];
		int _Count = sprintf(_Buf, "%p", _Val);	

		size_t _Fillcount = _Ios.width() <= 0 || _Ios.width() <= _Count
			? 0 : (size_t)_Ios.width() - _Count;

		if ((_Ios.flags() & ios_base::adjustfield) != ios_base::left)
			{	
			_Dest = _Rep(_Dest, _Fill, _Fillcount);
			_Fillcount = 0; }
		_Dest = _Putc(_Dest, _Buf, _Count);	
		_Ios.width(0);
		return (_Rep(_Dest, _Fill, _Fillcount)); }	

	static char *_Ffmt(char *_Fmt, char _Spec,
		ios_base::fmtflags _Flags)
		{	
		char *_Ptr = _Fmt;
		*_Ptr++ = '%';

		if (_Flags & ios_base::showpos)
			*_Ptr++ = '+';
		if (_Flags & ios_base::showpoint)
			*_Ptr++ = '#';
		*_Ptr++ = '.';
		*_Ptr++ = '*';	
		if (_Spec != '\0')
			*_Ptr++ = _Spec;	

		ios_base::fmtflags _Ffl = _Flags & ios_base::floatfield;
		*_Ptr++ = _Ffl == ios_base::fixed ? 'f'
			: _Ffl == ios_base::scientific ? 'e' : 'g';	
		*_Ptr = '\0';
		return (_Fmt); }

	static _OutIt _Fput(_OutIt _Dest, ios_base& _Ios,
		_Elem _Fill, const char *_Buf,
			size_t _Beforepoint, size_t _Afterpoint,
				size_t _Trailing, size_t _Count)
		{	
		_Elem _E0 = _Widen('0', (_Elem *)0);
		size_t _Fillcount = _Beforepoint + _Afterpoint + _Trailing + _Count;
		_Fillcount = _Ios.width() <= 0 || (size_t)_Ios.width() <= _Fillcount
			? 0 : (size_t)_Ios.width() - _Fillcount;

		ios_base::fmtflags _Adjustfield =
			_Ios.flags() & ios_base::adjustfield;
		if (_Adjustfield != ios_base::left
			&& _Adjustfield != ios_base::internal)
			{	
			_Dest = _Rep(_Dest, _Fill, _Fillcount);
			_Fillcount = 0; }
		else if (_Adjustfield == ios_base::internal)
			{	
			if (0 < _Count && (*_Buf == '+' || *_Buf == '-'))
				{	
				_Dest = _Putc(_Dest, _Buf, 1);
				++_Buf, --_Count; }
			_Dest = _Rep(_Dest, _Fill, _Fillcount);
			_Fillcount = 0; }

		const char *_Ptr = (const char *)memchr(_Buf,
			localeconv()->decimal_point[0], _Count);	
		if (_Ptr != 0)
			{	
			const _Mypunct& _Fac = use_facet<_Mypunct >(_Ios . getloc());
			size_t _Fracoffset = _Ptr - _Buf + 1;
			_Dest = _Putc(_Dest, _Buf, _Fracoffset - 1);
			_Dest = _Rep(_Dest, _E0, _Beforepoint);
			_Dest = _Rep(_Dest, _Fac.decimal_point(), 1);
			_Dest = _Rep(_Dest, _E0, _Afterpoint);
			_Buf += _Fracoffset, _Count -= _Fracoffset; }

		if ((_Ptr = (const char *)memchr(_Buf, 'e', _Count)) != 0)
			{	
			size_t _Expoffset = _Ptr - _Buf + 1;
			_Dest = _Putc(_Dest, _Buf, _Expoffset - 1);
			_Dest = _Rep(_Dest, _E0, _Trailing), _Trailing = 0;
			_Dest = _Putc(_Dest, _Ios.flags() & ios_base::uppercase
				? "E" : "e", 1);
			_Buf += _Expoffset, _Count -= _Expoffset; }

		_Dest = _Putc(_Dest, _Buf, _Count);	
		_Dest = _Rep(_Dest, _E0, _Trailing);	
		_Ios.width(0);
		return (_Rep(_Dest, _Fill, _Fillcount)); }	

	static char *_Ifmt(char *_Fmt, const char *_Spec,
		ios_base::fmtflags _Flags)
		{	
		char *_Ptr = _Fmt;
		*_Ptr++ = '%';

		if (_Flags & ios_base::showpos)
			*_Ptr++ = '+';
		if (_Flags & ios_base::showbase)
			*_Ptr++ = '#';
		*_Ptr++ = _Spec[0];	

		ios_base::fmtflags _Basefield = _Flags & ios_base::basefield;
		*_Ptr++ = _Basefield == ios_base::oct ? 'o'
			: _Basefield != ios_base::hex ? _Spec[1]	
			: _Flags & ios_base::uppercase ? 'X' : 'x';
		*_Ptr = '\0';
		return (_Fmt); }

	static _OutIt _Iput(_OutIt _Dest, ios_base& _Ios, _Elem _Fill,
		char *_Buf, size_t _Count)
		{	
		const size_t _Prefix = *_Buf == '+' || *_Buf == '-' ? 1
			: *_Buf == '0' && (_Buf[1] == 'x' || _Buf[1] == 'X') ? 2
			: 0;
		const _Mypunct& _Fac = use_facet<_Mypunct >(_Ios . getloc());
		const string _Grouping = _Fac.grouping();
		const _Elem _Kseparator = _Fac.thousands_sep();
		bool _Grouped = '\0' < *_Grouping.c_str();

		if (_Grouped)
			{	
			const char *_Pg = _Grouping.c_str();
			size_t _Off = _Count;
			for (_Grouped = false; *_Pg != 127 && '\0' < *_Pg
				&& (size_t)*_Pg < _Off - _Prefix; _Grouped = true)
				{	
				_Off -= *_Pg;
				memmove(&_Buf[_Off + 1], &_Buf[_Off], _Count + 1 - _Off);
				_Buf[_Off] = ',', ++_Count;
				if ('\0' < _Pg[1])
					++_Pg; }}	

		size_t _Fillcount = _Ios.width() <= 0
			|| (size_t)_Ios.width() <= _Count
				? 0 : (size_t)_Ios.width() - _Count;

		ios_base::fmtflags _Adjustfield =
			_Ios.flags() & ios_base::adjustfield;
		if (_Adjustfield != ios_base::left
			&& _Adjustfield != ios_base::internal)
			{	
			_Dest = _Rep(_Dest, _Fill, _Fillcount);
			_Fillcount = 0; }
		else if (_Adjustfield == ios_base::internal)
			{	
			_Dest = _Putc(_Dest, _Buf, _Prefix);	
			_Buf += _Prefix, _Count -= _Prefix;
			_Dest = _Rep(_Dest, _Fill, _Fillcount), _Fillcount = 0; }

		if (!_Grouped)
			_Dest = _Putc(_Dest, _Buf, _Count);	
		else
			for (; ; ++_Buf, --_Count)
				{	
				size_t _Groupsize = strcspn(_Buf, ",");
				_Dest = _Putc(_Dest, _Buf, _Groupsize);
				_Buf += _Groupsize, _Count -= _Groupsize;
				if (_Count == 0)
					break;
				if (_Kseparator != (_Elem)0)
					_Dest = _Rep(_Dest, _Kseparator, 1); }

		_Ios.width(0);
		return (_Rep(_Dest, _Fill, _Fillcount)); }	

	static _OutIt _Put(_OutIt _Dest, const _Elem *_Ptr, size_t _Count)
		{	
		for (; 0 < _Count; --_Count, ++_Dest, ++_Ptr)
			*_Dest = *_Ptr;
		return (_Dest); }

	static _OutIt _Putc(_OutIt _Dest, const char *_Ptr, size_t _Count)
		{	
		for (; 0 < _Count; --_Count, ++_Dest, ++_Ptr)
			*_Dest = _Widen(*_Ptr, (_Elem *)0);
		return (_Dest); }

	static _OutIt _Rep(_OutIt _Dest, _Elem _Char, size_t _Count)
		{	
		for (; 0 < _Count; --_Count, ++_Dest)
			*_Dest = _Char;
		return (_Dest); }
	};

		
template<class _Elem,
	class _OutIt>
	locale::id num_put<_Elem, _OutIt>::id;

}	





 
#line 5 "/usr/include/CC/ios"

namespace std {

		
template<class _Elem,
	class _Traits>
	class basic_ios
		: public ios_base
	{	
public:
	typedef basic_ios<_Elem, _Traits> _Myt;
	typedef basic_ostream<_Elem, _Traits> _Myos;
	typedef basic_streambuf<_Elem, _Traits> _Mysb;
	typedef ctype<_Elem> _Ctype;
	typedef _Elem char_type;
	typedef _Traits traits_type;
	typedef typename _Traits::int_type int_type;
	typedef typename _Traits::pos_type pos_type;
	typedef typename _Traits::off_type off_type;

	explicit basic_ios(_Mysb *_Strbuf)
		{	
		init(_Strbuf); }

	virtual ~basic_ios()
		{}	

	void clear(iostate _State = goodbit, bool _Except = false)
		{	
		ios_base::clear((iostate)(_Mystrbuf == 0
			? (int)_State | (int)badbit : (int)_State), _Except); }

	void clear(io_state _State)
		{	
		clear((iostate)_State); }

	void setstate(iostate _State, bool _Except = false)
		{	
		if (_State != goodbit)
			clear((iostate)((int)rdstate() | (int)_State), _Except); }

	void setstate(io_state _State)
		{	
		setstate((iostate)_State); }

	_Myt& copyfmt(const _Myt& _Right)
		{	
		_Tiestr = _Right.tie();
		_Fillch = _Right.fill();
		ios_base::copyfmt(_Right);
		return (*this); }

	_Myos *tie() const
		{	
		return (_Tiestr); }

	_Myos *tie(_Myos *_Newtie)
		{	
		_Myos *_Oldtie = _Tiestr;
		_Tiestr = _Newtie;
		return (_Oldtie); }

	_Mysb *rdbuf() const
		{	
		return (_Mystrbuf); }

	_Mysb *rdbuf(_Mysb *_Strbuf)
		{	
		_Mysb *_Oldstrbuf = _Mystrbuf;
		_Mystrbuf = _Strbuf;
		clear();
		return (_Oldstrbuf); }

	locale imbue(const locale& _Locale)
		{	
		if (rdbuf() != 0)
			rdbuf()->pubimbue(_Locale);
		return (ios_base::imbue(_Locale)); }

	_Elem fill() const
		{	
		return (_Fillch); }

	_Elem fill(_Elem _Newfill)
		{	
		_Elem _Oldfill = _Fillch;
		_Fillch = _Newfill;
		return (_Oldfill); }

	char narrow(_Elem _Char, char _Default = '\0') const
		{	
		const _Ctype& _Facet = use_facet<_Ctype >(getloc());
		return (_Facet.narrow(_Char, _Default)); }

	_Elem widen(char _Byte) const
		{	
		const _Ctype& _Facet = use_facet<_Ctype >(getloc());
		return (_Facet.widen(_Byte)); }

protected:
	void init(_Mysb *_Strbuf = 0, bool _Isstd = false)
		{	
		_Mystrbuf = _Strbuf;
		_Tiestr = 0;
		_Fillch = _Widen(' ', (_Elem *)0);
		_Init();	

		if (_Mystrbuf == 0)
			setstate(badbit);
		if (_Isstd)
			_Addstd(); }	

	basic_ios()
		{}	

private:
	basic_ios(const _Myt&);	
	basic_ios& operator=(const _Myt&);	
	_Mysb *_Mystrbuf;	
	_Myos *_Tiestr;	
	_Elem _Fillch;	
	};

		
inline ios_base& boolalpha(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::boolalpha);
	return (_Iosbase); }

inline ios_base& dec(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::dec, ios_base::basefield);
	return (_Iosbase); }

inline ios_base& fixed(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::fixed, ios_base::floatfield);
	return (_Iosbase); }

inline ios_base& hex(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::hex, ios_base::basefield);
	return (_Iosbase); }

inline ios_base& internal(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::internal, ios_base::adjustfield);
	return (_Iosbase); }

inline ios_base& left(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::left, ios_base::adjustfield);
	return (_Iosbase); }

inline ios_base& noboolalpha(ios_base& _Iosbase)
	{	
	_Iosbase.unsetf(ios_base::boolalpha);
	return (_Iosbase); }

inline ios_base& noshowbase(ios_base& _Iosbase)
	{	
	_Iosbase.unsetf(ios_base::showbase);
	return (_Iosbase); }

inline ios_base& noshowpoint(ios_base& _Iosbase)
	{	
	_Iosbase.unsetf(ios_base::showpoint);
	return (_Iosbase); }

inline ios_base& noshowpos(ios_base& _Iosbase)
	{	
	_Iosbase.unsetf(ios_base::showpos);
	return (_Iosbase); }

inline ios_base& noskipws(ios_base& _Iosbase)
	{	
	_Iosbase.unsetf(ios_base::skipws);
	return (_Iosbase); }

inline ios_base& nounitbuf(ios_base& _Iosbase)
	{	
	_Iosbase.unsetf(ios_base::unitbuf);
	return (_Iosbase); }

inline ios_base& nouppercase(ios_base& _Iosbase)
	{	
	_Iosbase.unsetf(ios_base::uppercase);
	return (_Iosbase); }

inline ios_base& oct(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::oct, ios_base::basefield);
	return (_Iosbase); }

inline ios_base& right(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::right, ios_base::adjustfield);
	return (_Iosbase); }

inline ios_base& scientific(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::scientific, ios_base::floatfield);
	return (_Iosbase); }

inline ios_base& showbase(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::showbase);
	return (_Iosbase); }

inline ios_base& showpoint(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::showpoint);
	return (_Iosbase); }

inline ios_base& showpos(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::showpos);
	return (_Iosbase); }

inline ios_base& skipws(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::skipws);
	return (_Iosbase); }

inline ios_base& unitbuf(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::unitbuf);
	return (_Iosbase); }

inline ios_base& uppercase(ios_base& _Iosbase)
	{	
	_Iosbase.setf(ios_base::uppercase);
	return (_Iosbase); }

}	





 
#line 5 "/usr/include/CC/ostream"

namespace std {

		










		
template<class _Elem, class _Traits>
	class basic_ostream
		: virtual public basic_ios<_Elem, _Traits>
	{	
public:
	typedef basic_ostream<_Elem, _Traits> _Myt;
	typedef basic_ios<_Elem, _Traits> _Myios;
	typedef basic_streambuf<_Elem, _Traits> _Mysb;
	typedef ostreambuf_iterator<_Elem, _Traits> _Iter;
	typedef num_put<_Elem, _Iter> _Nput;

	explicit basic_ostream(basic_streambuf<_Elem, _Traits> *_Strbuf,
		bool _Isstd = false)
		{	
		_Myios::init(_Strbuf, _Isstd); }

	basic_ostream(_Uninitialized)
		{	
		ios_base::_Addstd(); }

	virtual ~basic_ostream()
		{}	

	typedef typename _Traits::int_type int_type;
	typedef typename _Traits::pos_type pos_type;
	typedef typename _Traits::off_type off_type;

	class sentry
		{	
	public:
		explicit sentry(_Myt& _Ostr)
			: _Lock(2), _Myostr(_Ostr)
			{	
			if (_Ostr.good() && _Ostr.tie() != 0)
				_Ostr.tie()->flush();
			_Ok = _Ostr.good(); }	

		~sentry()
			{	
			if (!uncaught_exception())
				_Myostr._Osfx(); }

		operator bool() const
			{	
			return (_Ok); }

	private:
		sentry(const sentry&);	

		sentry& operator=(const sentry&);	

		_Lockit _Lock;	
		bool _Ok;	
		_Myt& _Myostr;	
		};

	void _Osfx()
		{	
		if (ios_base::flags() & ios_base::unitbuf)
			flush(); }	

	_Myt& operator<<(_Myt& (*_Fn)(_Myt&))
		{	
		return ((*_Fn)(*this)); }

	_Myt& operator<<(_Myios& (*_Fn)(_Myios&))
		{	
		(*_Fn)(*(_Myios *)this);
		return (*this); }

	_Myt& operator<<(ios_base& (*_Fn)(ios_base&))
		{	
		(*_Fn)(*(ios_base *)this);
		return (*this); }

	_Myt& operator<<(_Bool _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), _Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(short _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());
			ios_base::fmtflags _Bfl =
				ios_base::flags() & ios_base::basefield;
			long _Tmp = (_Bfl == ios_base::oct
				|| _Bfl == ios_base::hex)
				? (long)(unsigned short)_Val : (long)_Val;

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), _Tmp).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(unsigned short _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), (unsigned long)_Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(int _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());
			ios_base::fmtflags _Bfl =
				ios_base::flags() & ios_base::basefield;
			long _Tmp = (_Bfl == ios_base::oct
				|| _Bfl == ios_base::hex)
				? (long)(unsigned int)_Val : (long)_Val;

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), _Tmp).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(unsigned int _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), (unsigned long)_Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(long _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), _Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(unsigned long _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), _Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }


	_Myt& operator<<(long long _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), _Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(unsigned long long _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), _Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }


	_Myt& operator<<(float _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), (double)_Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(double _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), _Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(long double _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), _Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(const void *_Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nput& _Fac = use_facet<_Nput >(ios_base::getloc());

			try {
			if (_Fac.put(_Iter(_Myios::rdbuf()), *this,
				_Myios::fill(), _Val).failed())
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator<<(_Mysb *_Pstrbuf)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		bool _Copied = false;
		const sentry _Ok(*this);

		if (_Ok && _Pstrbuf != 0)
			for (int_type _Meta = _Traits::eof(); ; _Copied = true)
				{	
				try {
				_Meta = _Traits::eq_int_type(_Traits::eof(), _Meta)
					? _Pstrbuf->sgetc() : _Pstrbuf->snextc();
				 } catch (...) {
					_Myios::setstate(ios_base::failbit);
					throw;
				}

				if (_Traits::eq_int_type(_Traits::eof(), _Meta))
					break;	

				try {
					if (_Traits::eq_int_type(_Traits::eof(),
						_Myios::rdbuf()->sputc(
							_Traits::to_char_type(_Meta))))
						{	
						_State |= ios_base::badbit;
						break; }
				} catch (...) {
				_Myios::setstate(ios_base::badbit, true); }}

		ios_base::width(0);
		_Myios::setstate(!_Copied ? _State | ios_base::failbit : _State);
		return (*this); }

	_Myt& put(_Elem _Char)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (!_Ok)
			_State |= ios_base::badbit;
		else
			{	
			try {
			if (_Traits::eq_int_type(_Traits::eof(),
				_Myios::rdbuf()->sputc(_Char)))
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& write(const _Elem *_Str, streamsize _Count)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (!_Ok)
			_State |= ios_base::badbit;
		else
			{	
			try {
			if (_Myios::rdbuf()->sputn(_Str, _Count) != _Count)
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& flush()
		{	
		ios_base::iostate _State = ios_base::goodbit;
		if (!ios_base::fail() && _Myios::rdbuf()->pubsync() == -1)
			_State |= ios_base::badbit;	
		_Myios::setstate(_State);
		return (*this); }

	_Myt& seekp(pos_type _Pos)
		{	
		if (!ios_base::fail())
			_Myios::rdbuf()->pubseekpos(_Pos, ios_base::out);
		return (*this); }

	_Myt& seekp(off_type _Off, ios_base::seekdir _Way)
		{	
		if (!ios_base::fail())
			_Myios::rdbuf()->pubseekoff(_Off, _Way, ios_base::out);
		return (*this); }

	pos_type tellp()
		{	
		if (!ios_base::fail())
			return (_Myios::rdbuf()->pubseekoff(0,
				ios_base::cur, ios_base::out));
		else
			return (pos_type(_BADOFF)); }
	};

		
template<class _Elem, class _Traits> inline
	basic_ostream<_Elem, _Traits>& operator<<(
		basic_ostream<_Elem, _Traits>& _Ostr, const char *_Val)
	{	
	ios_base::iostate _State = ios_base::goodbit;
	streamsize _Count = (streamsize)strlen(_Val);	
	streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count
		? 0 : _Ostr.width() - _Count;
	const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);

	if (!_Ok)
		_State |= ios_base::badbit;
	else
		{	
		try {
		const ctype<_Elem>& _Fac = use_facet<ctype<_Elem> >(_Ostr . getloc());
		if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
			for (; 0 < _Pad; --_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					{	
					_State |= ios_base::badbit;
					break; }

		for (; _State == ios_base::goodbit && 0 < _Count; --_Count, ++_Val)
			if (_Traits::eq_int_type(_Traits::eof(),
				_Ostr.rdbuf()->sputc(_Fac.widen(*_Val))))
					_State |= ios_base::badbit;

		if (_State == ios_base::goodbit)
			for (; 0 < _Pad; --_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					{	
					_State |= ios_base::badbit;
					break; }
		_Ostr.width(0);
		} catch (...) {
		_Ostr.setstate(ios_base::badbit, true); }}

	_Ostr.setstate(_State);
	return (_Ostr); }

template<class _Elem, class _Traits> inline
	basic_ostream<_Elem, _Traits>& operator<<(
		basic_ostream<_Elem, _Traits>& _Ostr, char _Char)
	{	
	ios_base::iostate _State = ios_base::goodbit;
	const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);

	if (_Ok)
		{	
		const ctype<_Elem>& _Fac = use_facet<ctype<_Elem> >(_Ostr . getloc());
		streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;

		try {
		if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
			for (; _State == ios_base::goodbit && 0 < _Pad;
				--_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					_State |= ios_base::badbit;

		if (_State == ios_base::goodbit
			&& _Traits::eq_int_type(_Traits::eof(),
				_Ostr.rdbuf()->sputc(_Fac.widen(_Char))))
			_State |= ios_base::badbit;

		for (; _State == ios_base::goodbit && 0 < _Pad;
			--_Pad)	
			if (_Traits::eq_int_type(_Traits::eof(),
				_Ostr.rdbuf()->sputc(_Ostr.fill())))
				_State |= ios_base::badbit;
		} catch (...) {
		_Ostr.setstate(ios_base::badbit, true); }}

	_Ostr.width(0);
	_Ostr.setstate(_State);
	return (_Ostr); }

template<class _Traits> inline
	basic_ostream<char, _Traits>& operator<<(
		basic_ostream<char, _Traits>& _Ostr,
		const char *_Val)
	{	
	typedef char _Elem;
	typedef basic_ostream<_Elem, _Traits> _Myos;
	ios_base::iostate _State = ios_base::goodbit;
	streamsize _Count = (streamsize)_Traits::length(_Val);	
	streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count
		? 0 : _Ostr.width() - _Count;
	const typename _Myos::sentry _Ok(_Ostr);

	if (!_Ok)
		_State |= ios_base::badbit;
	else
		{	
		try {
		if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
			for (; 0 < _Pad; --_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					{	
					_State |= ios_base::badbit;
					break; }

		if (_State == ios_base::goodbit
			&& _Ostr.rdbuf()->sputn(_Val, _Count) != _Count)
			_State |= ios_base::badbit;

		if (_State == ios_base::goodbit)
			for (; 0 < _Pad; --_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					{	
					_State |= ios_base::badbit;
					break; }
		_Ostr.width(0);
		} catch (...) {
		_Ostr.setstate(ios_base::badbit, true); }}

	_Ostr.setstate(_State);
	return (_Ostr); }

template<class _Traits> inline
	basic_ostream<char, _Traits>& operator<<(
		basic_ostream<char, _Traits>& _Ostr, char _Char)
	{	
	typedef char _Elem;
	typedef basic_ostream<_Elem, _Traits> _Myos;
	ios_base::iostate _State = ios_base::goodbit;
	const typename _Myos::sentry _Ok(_Ostr);

	if (_Ok)
		{	
		streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;

		try {
		if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
			for (; _State == ios_base::goodbit && 0 < _Pad;
				--_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					_State |= ios_base::badbit;

		if (_State == ios_base::goodbit
			&& _Traits::eq_int_type(_Traits::eof(),
				_Ostr.rdbuf()->sputc(_Char)))
			_State |= ios_base::badbit;

		for (; _State == ios_base::goodbit && 0 < _Pad;
			--_Pad)	
			if (_Traits::eq_int_type(_Traits::eof(),
				_Ostr.rdbuf()->sputc(_Ostr.fill())))
				_State |= ios_base::badbit;
		} catch (...) {
		_Ostr.setstate(ios_base::badbit, true); }}

	_Ostr.width(0);
	_Ostr.setstate(_State);
	return (_Ostr); }

template<class _Elem, class _Traits> inline
	basic_ostream<_Elem, _Traits>& operator<<(
		basic_ostream<_Elem, _Traits>& _Ostr, const _Elem *_Val)
	{	
	typedef basic_ostream<_Elem, _Traits> _Myos;
	ios_base::iostate _State = ios_base::goodbit;
	streamsize _Count = (streamsize)_Traits::length(_Val);	
	streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count
		? 0 : _Ostr.width() - _Count;
	const typename _Myos::sentry _Ok(_Ostr);

	if (!_Ok)
		_State |= ios_base::badbit;
	else
		{	
		try {
		if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
			for (; 0 < _Pad; --_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					{	
					_State |= ios_base::badbit;
					break; }

		if (_State == ios_base::goodbit
			&& _Ostr.rdbuf()->sputn(_Val, _Count) != _Count)
			_State |= ios_base::badbit;

		if (_State == ios_base::goodbit)
			for (; 0 < _Pad; --_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					{	
					_State |= ios_base::badbit;
					break; }
		_Ostr.width(0);
		} catch (...) {
		_Ostr.setstate(ios_base::badbit, true); }}

	_Ostr.setstate(_State);
	return (_Ostr); }

template<class _Elem, class _Traits> inline
	basic_ostream<_Elem, _Traits>& operator<<(
		basic_ostream<_Elem, _Traits>& _Ostr, _Elem _Char)
	{	
	typedef basic_ostream<_Elem, _Traits> _Myos;
	ios_base::iostate _State = ios_base::goodbit;
	const typename _Myos::sentry _Ok(_Ostr);

	if (_Ok)
		{	
		streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;

		try {
		if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
			for (; _State == ios_base::goodbit && 0 < _Pad;
				--_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					_State |= ios_base::badbit;

		if (_State == ios_base::goodbit
			&& _Traits::eq_int_type(_Traits::eof(),
				_Ostr.rdbuf()->sputc(_Char)))
			_State |= ios_base::badbit;

		for (; _State == ios_base::goodbit && 0 < _Pad;
			--_Pad)	
			if (_Traits::eq_int_type(_Traits::eof(),
				_Ostr.rdbuf()->sputc(_Ostr.fill())))
				_State |= ios_base::badbit;
		} catch (...) {
		_Ostr.setstate(ios_base::badbit, true); }}

	_Ostr.width(0);
	_Ostr.setstate(_State);
	return (_Ostr); }

template<class _Traits> inline
	basic_ostream<char, _Traits>& operator<<(
		basic_ostream<char, _Traits>& _Ostr, const signed char *_Val)
	{	
	return (_Ostr << (const char *)_Val); }

template<class _Traits> inline
	basic_ostream<char, _Traits>& operator<<(
		basic_ostream<char, _Traits>& _Ostr, signed char _Char)
	{	
	return (_Ostr << (char)_Char); }

template<class _Traits> inline
	basic_ostream<char, _Traits>& operator<<(
		basic_ostream<char, _Traits>& _Ostr, const unsigned char *_Val)
	{	
	return (_Ostr << (const char *)_Val); }

template<class _Traits> inline
	basic_ostream<char, _Traits>& operator<<(
		basic_ostream<char, _Traits>& _Ostr, unsigned char _Char)
	{	
	return (_Ostr << (char)_Char); }

		
template<class _Elem, class _Traits> inline
	basic_ostream<_Elem, _Traits>&
		endl(basic_ostream<_Elem, _Traits>& _Ostr)
	{	
	_Ostr.put(_Ostr.widen('\n'));
	_Ostr.flush();
	return (_Ostr); }

template<class _Elem, class _Traits> inline
	basic_ostream<_Elem, _Traits>&
		ends(basic_ostream<_Elem, _Traits>& _Ostr)
	{	
	_Ostr.put(_Elem());
	return (_Ostr); }

template<class _Elem, class _Traits> inline
	basic_ostream<_Elem, _Traits>&
		flush(basic_ostream<_Elem, _Traits>& _Ostr)
	{	
	_Ostr.flush();
	return (_Ostr); }

}	





 
#line 5 "/usr/include/CC/istream"

namespace std {

		
template<class Elem,
	class _Traits>
	class basic_istream
		: virtual public basic_ios<Elem, _Traits>
	{	
public:
	typedef basic_istream<Elem, _Traits> _Myt;
	typedef basic_ios<Elem, _Traits> _Myios;
	typedef basic_streambuf<Elem, _Traits> _Mysb;
	typedef istreambuf_iterator<Elem, _Traits> _Iter;
	typedef ctype<Elem> _Ctype;
	typedef num_get<Elem, _Iter> _Nget;

	explicit basic_istream(_Mysb *_Strbuf, bool _Isstd = false,
		bool _Noinit = false)
		: _Chcount(0)
		{	
		if (!_Noinit)
			_Myios::init(_Strbuf, _Isstd); }

	basic_istream(_Uninitialized)
		{	
		ios_base::_Addstd(); }

	virtual ~basic_istream()
		{}	

	typedef typename _Traits::int_type int_type;
	typedef typename _Traits::pos_type pos_type;
	typedef typename _Traits::off_type off_type;

		
	class sentry
		{	
	public:
		explicit sentry(_Myt& _Istr, bool _Noskip = false)
			: _Lock(2), _Ok(_Istr._Ipfx(_Noskip))
			{}	

		operator bool() const
			{	
			return (_Ok); }

	private:
		sentry(const sentry&);	

		sentry& operator=(const sentry&);	

		_Lockit _Lock;	
		bool _Ok;	
		};

	bool _Ipfx(bool _Noskip = false)
		{	
		if (ios_base::good())
			{	
			if (_Myios::tie() != 0)
				_Myios::tie()->flush();

			if (!_Noskip && ios_base::flags() & ios_base::skipws)
				{	
				const _Ctype& _Facet = use_facet<_Ctype >(ios_base::getloc());

				try {
				int_type _Meta = _Myios::rdbuf()->sgetc();

				for (; ; _Meta = _Myios::rdbuf()->snextc())
					if (_Traits::eq_int_type(_Traits::eof(), _Meta))
						{	
						_Myios::setstate(ios_base::eofbit);
						break; }
					else if (!_Facet.is(_Ctype::space,
						_Traits::to_char_type(_Meta)))
						break;	
				} catch (...) {
				_Myios::setstate(ios_base::badbit, true); }}

			if (ios_base::good())
				return (true); }
		_Myios::setstate(ios_base::failbit);
		return (false); }

	_Myt& operator>>(_Myt& (*_Fn)(_Myt&))
		{	
		return ((*_Fn)(*this)); }

	_Myt& operator>>(_Myios& (*_Fn)(_Myios&))
		{	
		(*_Fn)(*(_Myios *)this);
		return (*this); }

	_Myt& operator>>(ios_base& (*_Fn)(ios_base&))
		{	
		(*_Fn)(*(ios_base *)this);
		return (*this); }

	_Myt& operator>>(_Bool& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(short& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			long _Tmp = 0;
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Tmp);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }

			if (_State & ios_base::failbit
				|| _Tmp < (-32768) || 32767 < _Tmp)
				_State |= ios_base::failbit;
			else
				_Val = (short)_Tmp; }

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(unsigned short& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(int& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			long _Tmp = 0;
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Tmp);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }

			if (_State & ios_base::failbit
				|| _Tmp < (-0x7fffffff-1) || 0x7fffffff < _Tmp)
				_State |= ios_base::failbit;
			else
				_Val = _Tmp; }

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(unsigned int& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);
		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(long& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());
			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(unsigned long& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }


	_Myt& operator>>(long long& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(unsigned long long& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);
		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }


	_Myt& operator>>(float& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(double& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);
		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(long double& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());
			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(void *& _Val)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		const sentry _Ok(*this);

		if (_Ok)
			{	
			const _Nget& _Facet = use_facet<_Nget >(ios_base::getloc());

			try {
			_Facet.get(_Iter(_Myios::rdbuf()), _Iter(0),
				*this, _State, _Val);
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& operator>>(_Mysb *_Pstrbuf)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		bool _Copied = false;
		const sentry _Ok(*this);

		if (_Ok && _Pstrbuf != 0)
			{	
			try {
			int_type _Meta = _Myios::rdbuf()->sgetc();

			for (; ; _Meta = _Myios::rdbuf()->snextc())
				if (_Traits::eq_int_type(_Traits::eof(), _Meta))
					{	
					_State |= ios_base::eofbit;
					break; }
				else
					{	
					try {
						if (_Traits::eq_int_type(_Traits::eof(),
							_Pstrbuf->sputc(_Traits::to_char_type(_Meta))))
							break;
					 } catch (...) {
						break;
					}
					_Copied = true; }
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(!_Copied ? _State | ios_base::failbit : _State);
		return (*this); }

	int_type get()
		{	
		int_type _Meta = 0;
		ios_base::iostate _State = ios_base::goodbit;
		_Chcount = 0;
		const sentry _Ok(*this, true);

		if (!_Ok)
			_Meta = _Traits::eof();	
		else
			{	
			try {
			_Meta = _Myios::rdbuf()->sbumpc();

			if (_Traits::eq_int_type(_Traits::eof(), _Meta))
				_State |= ios_base::eofbit | ios_base::failbit;	
			else
				++_Chcount;	
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (_Meta); }

	_Myt& get(Elem *_Str, streamsize _Count)
		{	
		return (get(_Str, _Count, _Myios::widen('\n'))); }

	_Myt& get(Elem *_Str, streamsize _Count, Elem _Delim)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		_Chcount = 0;
		const sentry _Ok(*this, true);

		if (_Ok && 0 < _Count)
			{	
			try {
			int_type _Meta = _Myios::rdbuf()->sgetc();

			for (; 0 < --_Count; _Meta = _Myios::rdbuf()->snextc())
				if (_Traits::eq_int_type(_Traits::eof(), _Meta))
					{	
					_State |= ios_base::eofbit;
					break; }
				else if (_Traits::to_char_type(_Meta) == _Delim)
					break;	
				else
					{	
					*_Str++ = _Traits::to_char_type(_Meta);
					++_Chcount; }
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_Chcount == 0
			? _State | ios_base::failbit : _State);
		*_Str = Elem();	
		return (*this); }

	_Myt& get(Elem& _Char)
		{	
		int_type _Meta = get();
		if (!_Traits::eq_int_type(_Traits::eof(), _Meta))
			_Char = _Traits::to_char_type(_Meta);
		return (*this); }

	_Myt& get(_Mysb& _Strbuf)
		{	
		return (get(_Strbuf, _Myios::widen('\n'))); }

	_Myt& get(_Mysb& _Strbuf, Elem _Delim)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		_Chcount = 0;
		const sentry _Ok(*this, true);

		if (_Ok)
			{	
			try {
			int_type _Meta = _Myios::rdbuf()->sgetc();

			for (; ; _Meta = _Myios::rdbuf()->snextc())
				if (_Traits::eq_int_type(_Traits::eof(), _Meta))
					{	
					_State |= ios_base::eofbit;
					break; }
				else
					{	
					try {
						Elem _Char = _Traits::to_char_type(_Meta);
						if (_Char == _Delim
							|| _Traits::eq_int_type(_Traits::eof(),
								_Strbuf.sputc(_Char)))
							break;
					 } catch (...) {
						break;
					}
					++_Chcount; }
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		if (_Chcount == 0)
			_State |= ios_base::failbit;
		_Myios::setstate(_State);
		return (*this); }

	_Myt& getline(Elem *_Str, streamsize _Count)
		{	
		return (getline(_Str, _Count, _Myios::widen('\n'))); }

	_Myt& getline(Elem *_Str, streamsize _Count, Elem _Delim)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		_Chcount = 0;
		const sentry _Ok(*this, true);

		if (_Ok && 0 < _Count)
			{	
			int_type _Metadelim = _Traits::to_int_type(_Delim);

			try {
			int_type _Meta = _Myios::rdbuf()->sgetc();

			for (; ; _Meta = _Myios::rdbuf()->snextc())
				if (_Traits::eq_int_type(_Traits::eof(), _Meta))
					{	
					_State |= ios_base::eofbit;
					break; }
				else if (_Meta == _Metadelim)
					{	
					++_Chcount;
					_Myios::rdbuf()->sbumpc();
					break; }
				else if (--_Count <= 0)
					{	
					_State |= ios_base::failbit;
					break; }
				else
					{	
					++_Chcount;
					*_Str++ = _Traits::to_char_type(_Meta); }
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		*_Str = Elem();	
		_Myios::setstate(_Chcount == 0 ? _State | ios_base::failbit : _State);
		return (*this); }

	_Myt& ignore(streamsize _Count = 1, int_type _Metadelim = _Traits::eof())
		{	
		ios_base::iostate _State = ios_base::goodbit;
		_Chcount = 0;
		const sentry _Ok(*this, true);

		if (_Ok && 0 < _Count)
			{	
			try {
			for (; ; )
				{	
				int_type _Meta;
				if (_Count != 0x7fffffff && --_Count < 0)
					break;	
				else if (_Traits::eq_int_type(_Traits::eof(),
					_Meta = _Myios::rdbuf()->sbumpc()))
					{	
					_State |= ios_base::eofbit;
					break; }
				else
					{	
					++_Chcount;
					if (_Meta == _Metadelim)
						break; }}	
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& read(Elem *_Str, streamsize _Count)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		_Chcount = 0;
		const sentry _Ok(*this, true);

		if (_Ok)
			{	
			try {
			const streamsize _Num = _Myios::rdbuf()->sgetn(_Str, _Count);
			_Chcount += _Num;
			if (_Num != _Count)
				_State |= ios_base::eofbit | ios_base::failbit;	
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	streamsize readsome(Elem *_Str, streamsize _Count)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		_Chcount = 0;
		const sentry _Ok(*this, true);
		int _Num;

		if (!_Ok)
			_State |= ios_base::failbit;	
		else if ((_Num = _Myios::rdbuf()->in_avail()) < 0)
			_State |= ios_base::eofbit;	
		else if (0 < _Num)
			read(_Str, _Num < _Count ? _Num : _Count);	

		_Myios::setstate(_State);
		return (gcount()); }

	int_type peek()
		{	
		ios_base::iostate _State = ios_base::goodbit;
		_Chcount = 0;
		int_type _Meta = 0;
		const sentry _Ok(*this, true);

		if (!_Ok)
			_Meta = _Traits::eof();	
		else
			{	
			try {
			if (_Traits::eq_int_type(_Traits::eof(),
				_Meta = _Myios::rdbuf()->sgetc()))
				_State |= ios_base::eofbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (_Meta); }

	_Myt& putback(Elem _Char)
		{	
		ios_base::iostate _State = ios_base::goodbit;
		_Chcount = 0;
		const sentry _Ok(*this, true);

		if (_Ok)
			{	
			try {
			if (_Traits::eq_int_type(_Traits::eof(),
				_Myios::rdbuf()->sputbackc(_Char)))
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	_Myt& unget()
		{	
		ios_base::iostate _State = ios_base::goodbit;
		_Chcount = 0;
		const sentry _Ok(*this, true);

		if (_Ok)
			{	
			try {
			if (_Traits::eq_int_type(_Traits::eof(),
				_Myios::rdbuf()->sungetc()))
				_State |= ios_base::badbit;
			} catch (...) {
			_Myios::setstate(ios_base::badbit, true); }}

		_Myios::setstate(_State);
		return (*this); }

	streamsize gcount() const
		{	
		return (_Chcount); }

	int sync()
		{	
		ios_base::iostate _State = ios_base::goodbit;
		int _Ans;

		if (_Myios::rdbuf() == 0)
			_Ans = -1;	
		else if (_Myios::rdbuf()->pubsync() == -1)
			{	
			_State |= ios_base::badbit;
			_Ans = -1; }
		else
			_Ans = 0;	

		_Myios::setstate(_State);
		return (_Ans); }

	_Myt& seekg(pos_type _Pos)
		{	
		if (!ios_base::fail())
			_Myios::rdbuf()->pubseekpos(_Pos, ios_base::in);
		return (*this); }

	_Myt& seekg(off_type _Off, ios_base::seekdir _Way)
		{	
		if (!ios_base::fail())
			_Myios::rdbuf()->pubseekoff(_Off, _Way, ios_base::in);
		return (*this); }

	pos_type tellg()
		{	
		if (!ios_base::fail())
			return (_Myios::rdbuf()->pubseekoff(0,
				ios_base::cur, ios_base::in));
		else
			return (pos_type(_BADOFF)); }

private:
	streamsize _Chcount;	
	};

		
template<class Elem,
	class _Traits>
	class basic_iostream
	: public basic_istream<Elem, _Traits>,
		public basic_ostream<Elem, _Traits>
	{	
public:
	explicit basic_iostream(basic_streambuf<Elem, _Traits> *_Strbuf)
		: basic_istream<Elem, _Traits>(_Strbuf, false, true),
			basic_ostream<Elem, _Traits>(_Strbuf)
		{}	

	virtual ~basic_iostream()
		{}	
	};

		
template<class Elem,
	class _Traits> inline
	basic_istream<Elem, _Traits>& operator>>(
		basic_istream<Elem, _Traits>& _Istr, Elem *_Val)
	{	
	typedef basic_istream<Elem, _Traits> _Myis;
	typedef ctype<Elem> _Ctype;
	ios_base::iostate _State = ios_base::goodbit;
	Elem *_Str = _Val;
	const typename _Myis::sentry _Ok(_Istr);

	if (_Ok)
		{	
		const _Ctype& _Facet = use_facet<_Ctype >(_Istr . getloc());

		try {
		int _Count = 0 < _Istr.width() ? _Istr.width() : 0x7fffffff;
		typename _Myis::int_type _Meta = _Istr.rdbuf()->sgetc();
		for (; 0 < --_Count; _Meta = _Istr.rdbuf()->snextc())
			if (_Traits::eq_int_type(_Traits::eof(), _Meta))
				{	
				_State |= ios_base::eofbit;
				break; }
			else if (_Facet.is(_Ctype::space,
				_Traits::to_char_type(_Meta)))
				break;	
			else
				*_Str++ = _Traits::to_char_type(_Meta);	
		} catch (...) {
		_Istr.setstate(ios_base::badbit, true); }}

	*_Str = Elem();	
	_Istr.width(0);
	_Istr.setstate(_Str == _Val ? _State | ios_base::failbit : _State);
	return (_Istr); }

template<class Elem,
	class _Traits> inline
	basic_istream<Elem, _Traits>& operator>>(
		basic_istream<Elem, _Traits>& _Istr, Elem& _Char)
	{	
	typedef basic_istream<Elem, _Traits> _Myis;
	typename _Myis::int_type _Meta;
	ios_base::iostate _State = ios_base::goodbit;
	const typename _Myis::sentry _Ok(_Istr);

	if (_Ok)
		{	
		try {
		_Meta = _Istr.rdbuf()->sbumpc();
		if (_Traits::eq_int_type(_Traits::eof(), _Meta))
			_State |= ios_base::eofbit | ios_base::failbit;	
		else
			_Char = _Traits::to_char_type(_Meta);	
		} catch (...) {
		_Istr.setstate(ios_base::badbit, true); }}

	_Istr.setstate(_State);
	return (_Istr); }

template<class _Traits> inline
	basic_istream<char, _Traits>& operator>>(
		basic_istream<char, _Traits>& _Istr, signed char *_Char)
	{	
	return (_Istr >> (char *)_Char); }

template<class _Traits> inline
	basic_istream<char, _Traits>& operator>>(
		basic_istream<char, _Traits>& _Istr, signed char& _Char)
	{	
	return (_Istr >> (char&)_Char); }

template<class _Traits> inline
	basic_istream<char, _Traits>& operator>>(
		basic_istream<char, _Traits>& _Istr, unsigned char *_Char)
	{	
	return (_Istr >> (char *)_Char); }

template<class _Traits> inline
	basic_istream<char, _Traits>& operator>>(
		basic_istream<char, _Traits>& _Istr, unsigned char& _Char)
	{	
	return (_Istr >> (char&)_Char); }

		
template<class Elem,
	class _Traits> inline
	basic_istream<Elem, _Traits>&
		ws(basic_istream<Elem, _Traits>& _Istr)
	{	
	typedef basic_istream<Elem, _Traits> _Myis;
	typedef ctype<Elem> _Ctype;
	ios_base::iostate _State = ios_base::goodbit;
	const typename _Myis::sentry _Ok(_Istr, true);

	if (_Ok)
		{	
		const _Ctype& _Facet = use_facet<_Ctype >(_Istr . getloc());

		try {
		for (typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc(); ;
			_Meta = _Istr.rdbuf()->snextc())
			if (_Traits::eq_int_type(_Traits::eof(), _Meta))
				{	
				_State |= ios_base::eofbit;
				break; }
			else if (!_Facet.is(_Ctype::space,
				_Traits::to_char_type(_Meta)))
				break;	
		} catch (...) {
		_Istr.setstate(ios_base::badbit, true); }}

	_Istr.setstate(_State);
	return (_Istr); }

}	





 
#line 5 "/usr/include/CC/string"

namespace std {

		
template<class _Elem,
	class _Traits,
	class _Alloc> inline
	basic_string<_Elem, _Traits, _Alloc> operator+(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (basic_string<_Elem, _Traits, _Alloc>(_Left) += _Right); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	basic_string<_Elem, _Traits, _Alloc> operator+(
		const _Elem *_Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (basic_string<_Elem, _Traits, _Alloc>(_Left) += _Right); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	basic_string<_Elem, _Traits, _Alloc> operator+(
		const _Elem _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (basic_string<_Elem, _Traits, _Alloc>(1, _Left) += _Right); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	basic_string<_Elem, _Traits, _Alloc> operator+(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const _Elem *_Right)
	{	
	return (basic_string<_Elem, _Traits, _Alloc>(_Left) += _Right); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	basic_string<_Elem, _Traits, _Alloc> operator+(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const _Elem _Right)
	{	
	return (basic_string<_Elem, _Traits, _Alloc>(_Left) += _Right); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator==(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (_Left.compare(_Right) == 0); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator==(
		const _Elem * _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (_Right.compare(_Left) == 0); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator==(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const _Elem *_Right)
	{	
	return (_Left.compare(_Right) == 0); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator!=(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (!(_Left == _Right)); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator!=(
		const _Elem *_Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (!(_Left == _Right)); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator!=(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const _Elem *_Right)
	{	
	return (!(_Left == _Right)); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator<(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (_Left.compare(_Right) < 0); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator<(
		const _Elem * _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (_Right.compare(_Left) > 0); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator<(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const _Elem *_Right)
	{	
	return (_Left.compare(_Right) < 0); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator>(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (_Right < _Left); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator>(
		const _Elem * _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (_Right < _Left); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator>(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const _Elem *_Right)
	{	
	return (_Right < _Left); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator<=(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (!(_Right < _Left)); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator<=(
		const _Elem * _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (!(_Right < _Left)); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator<=(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const _Elem *_Right)
	{	
	return (!(_Right < _Left)); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator>=(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (!(_Left < _Right)); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator>=(
		const _Elem * _Left,
		const basic_string<_Elem, _Traits, _Alloc>& _Right)
	{	
	return (!(_Left < _Right)); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	bool operator>=(
		const basic_string<_Elem, _Traits, _Alloc>& _Left,
		const _Elem *_Right)
	{	
	return (!(_Left < _Right)); }

		
template<class _Elem,
	class _Traits,
	class _Alloc> inline
	basic_istream<_Elem, _Traits>& operator>>(
		basic_istream<_Elem, _Traits>& _Istr,
		basic_string<_Elem, _Traits, _Alloc>& _Str)
	{	
	typedef ctype<_Elem> _Ctype;
	typedef basic_istream<_Elem, _Traits> _Myis;
	typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
	typedef typename _Mystr::size_type _Mysizt;

	ios_base::iostate _State = ios_base::goodbit;
	bool _Changed = false;
	const typename _Myis::sentry _Ok(_Istr);

	if (_Ok)
		{	
		const _Ctype& _Fac = use_facet<_Ctype >(_Istr . getloc());
		_Str.erase();

		try {
		_Mysizt _Size = 0 < _Istr.width()
			&& (_Mysizt)_Istr.width() < _Str.max_size()
				? (_Mysizt)_Istr.width() : _Str.max_size();
		typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();

		for (; 0 < _Size; --_Size, _Meta = _Istr.rdbuf()->snextc())
			if(_Traits::eq_int_type(_Traits::eof(), _Meta))
				{	
				_State |= ios_base::eofbit;
				break; }
			else if (_Fac.is(_Ctype::space, _Traits::to_char_type(_Meta)))
				break;	
			else
				{	
				_Str.append(1, _Traits::to_char_type(_Meta));
				_Changed = true; }
		} catch (...) {
		_Istr.setstate(ios_base::badbit, true); }}

	_Istr.width(0);
	if (!_Changed)
		_State |= ios_base::failbit;
	_Istr.setstate(_State);
	return (_Istr); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	basic_istream<_Elem, _Traits>& getline(
		basic_istream<_Elem, _Traits>& _Istr,
		basic_string<_Elem, _Traits, _Alloc>& _Str)
	{	
	return (getline(_Istr, _Str, _Istr.widen('\n'))); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	basic_istream<_Elem, _Traits>& getline(
		basic_istream<_Elem, _Traits>& _Istr,
		basic_string<_Elem, _Traits, _Alloc>& _Str, const _Elem _Delim)
	{	
	typedef basic_istream<_Elem, _Traits> _Myis;
	ios_base::iostate _State = ios_base::goodbit;
	bool _Changed = false;
	const typename _Myis::sentry _Ok(_Istr, true);

	if (_Ok)
		{	
		try {
		_Str.erase();
		const typename _Traits::int_type _Metadelim = 
			_Traits::to_int_type(_Delim);
		typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();

		for (; ; _Meta = _Istr.rdbuf()->snextc())
			if (_Traits::eq_int_type(_Traits::eof(), _Meta))
				{	
				_State |= ios_base::eofbit;
				break; }
			else if (_Traits::eq_int_type(_Meta, _Metadelim))
				{	
				_Changed = true;
				_Istr.rdbuf()->sbumpc();
				break; }
			else if (_Str.max_size() <= _Str.size())
				{	
				_State |= ios_base::failbit;
				break; }
			else
				{	
				_Str += _Traits::to_char_type(_Meta);
				_Changed = true; }
		} catch (...) {
		_Istr.setstate(ios_base::badbit, true); }}

	if (!_Changed)
		_State |= ios_base::failbit;
	_Istr.setstate(_State);
	return (_Istr); }

template<class _Elem,
	class _Traits,
	class _Alloc> inline
	basic_ostream<_Elem, _Traits>& operator<<(
		basic_ostream<_Elem, _Traits>& _Ostr,
		const basic_string<_Elem, _Traits, _Alloc>& _Str)
	{	
	typedef basic_ostream<_Elem, _Traits> _Myos;
	typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
	typedef typename _Mystr::size_type _Mysizt;

	ios_base::iostate _State = ios_base::goodbit;
	_Mysizt _Size = _Str.size();
	_Mysizt _Pad = _Ostr.width() <= 0 || (_Mysizt)_Ostr.width() <= _Size
			? 0 : (_Mysizt)_Ostr.width() - _Size;
	const typename _Myos::sentry _Ok(_Ostr);

	if (!_Ok)
		_State |= ios_base::badbit;
	else
		{	
	try {
		if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
			for (; 0 < _Pad; --_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					{	
					_State |= ios_base::badbit;
					break; }

		if (_State == ios_base::goodbit)
			for (_Mysizt _Count = 0; _Count < _Size; ++_Count)
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Str[_Count])))
					{	
					_State |= ios_base::badbit;
					break; }

		if (_State == ios_base::goodbit)
			for (; 0 < _Pad; --_Pad)	
				if (_Traits::eq_int_type(_Traits::eof(),
					_Ostr.rdbuf()->sputc(_Ostr.fill())))
					{	
					_State |= ios_base::badbit;
					break; }
		_Ostr.width(0);
		} catch (...) {
		_Ostr.setstate(ios_base::badbit, true); }}

	_Ostr.setstate(_State);
	return (_Ostr); }

}	





 
#line 41 "../../include/QtCore/../../src/corelib/tools/qstring.h"




typedef std::basic_string<wchar_t> QStdWString;












typedef QtValidLicenseForCoreModule QtCoreModule;

class QCharRef;
class QRegExp;
class QStringList;
class QTextCodec;
class QLatin1String;

class  QString
{
public:
    inline QString();
    QString(const QChar *unicode, int size);
    QString(QChar c);
    QString(int size, QChar c);
    inline QString(const QLatin1String &latin1);
    inline QString(const QString &);
    inline ~QString();
    QString &operator=(QChar c);
    QString &operator=(const QString &);
    inline QString &operator=(const QLatin1String &);

    inline int size() const { return d->size; }
    inline int count() const { return d->size; }
    inline int length() const;
    inline bool isEmpty() const;
    void resize(int size);

    QString &fill(QChar c, int size = -1);
    void truncate(int pos);
    void chop(int n);

    int capacity() const;
    inline void reserve(int size);
    inline void squeeze() { if (d->size < d->alloc) realloc(); }

    inline const QChar *unicode() const;
    inline QChar *data();
    inline const QChar *data() const;
    inline const QChar *constData() const;

    inline void detach();
    inline bool isDetached() const;
    void clear();

    inline const QChar at(int i) const;
    const QChar operator[](int i) const;
    QCharRef operator[](int i);
    const QChar operator[](uint i) const;
    QCharRef operator[](uint i);

    QString arg(qlonglong a, int fieldwidth=0, int base=10, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(qulonglong a, int fieldwidth=0, int base=10, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(long a, int fieldwidth=0, int base=10, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(ulong a, int fieldwidth=0, int base=10, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(int a, int fieldWidth = 0, int base = 10, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(uint a, int fieldWidth = 0, int base = 10, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(short a, int fieldWidth = 0, int base = 10, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(ushort a, int fieldWidth = 0, int base = 10, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(char a, int fieldWidth = 0, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(QChar a, int fieldWidth = 0, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(const QString &a, int fieldWidth = 0, const QChar &fillChar = QLatin1Char(' ')) const;
    QString arg(const QString &a1, const QString &a2) const;
    QString arg(const QString &a1, const QString &a2, const QString &a3) const;
    QString arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4) const;

    QString    &vsprintf(const char *format, va_list ap);
    QString    &sprintf(const char *format, ...)



        ;

    int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    inline QBool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    inline QBool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;


    int indexOf(const QRegExp &, int from = 0) const;
    int lastIndexOf(const QRegExp &, int from = -1) const;
    inline QBool contains(const QRegExp &rx) const { return QBool(indexOf(rx) != -1); }
    int count(const QRegExp &) const;


    enum SectionFlag {
        SectionDefault             = 0x00,
        SectionSkipEmpty           = 0x01,
        SectionIncludeLeadingSep   = 0x02,
        SectionIncludeTrailingSep  = 0x04,
        SectionCaseInsensitiveSeps = 0x08
    };
    typedef QFlags<SectionFlag> SectionFlags;

    QString section(QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;
    QString section(const QString &in_sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;

    QString section(const QRegExp &reg, int start, int end = -1, SectionFlags flags = SectionDefault) const;


    QString left(int len) const;
    QString right(int len) const;
    QString mid(int i, int len = -1) const;

    bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool startsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool startsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool endsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool endsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    QString leftJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const;
    QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const;

    QString toLower() const;
    QString toUpper() const;

    QString trimmed() const;
    QString simplified() const;

    QString &insert(int i, QChar c);
    QString &insert(int i, const QChar *uc, int len);
    inline QString &insert(int i, const QString &s) { return insert(i, s.constData(), s.length()); }
    QString &insert(int i, const QLatin1String &s);
    QString &append(QChar c);
    QString &append(const QString &s);
    QString &append(const QLatin1String &s);
    inline QString &prepend(QChar c) { return insert(0, c); }
    inline QString &prepend(const QString &s) { return insert(0, s); }
    inline QString &prepend(const QLatin1String &s) { return insert(0, s); }
    inline QString &operator+=(QChar c) { return append(c); }
    inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); }
    inline QString &operator+=(const QString &s) { return append(s); }
    inline QString &operator+=(const QLatin1String &s) { return append(s); }

    QString &remove(int i, int len);
    QString &remove(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &remove(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(int i, int len, QChar after);
    QString &replace(int i, int len, const QChar *s, int slen);
    QString &replace(int i, int len, const QString &after);
    QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(const QString &before, const QString &after,
                     Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &replace(const QRegExp &rx, const QString &after);
    inline QString &remove(const QRegExp &rx)
    { return replace(rx, QString()); }


    enum SplitBehavior { KeepEmptyParts, SkipEmptyParts };

    QStringList split(const QString &sep, SplitBehavior behavior = KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    QStringList split(const QChar &sep, SplitBehavior behavior = KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    QStringList split(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const;


    enum NormalizationForm {
        NormalizationForm_D,
        NormalizationForm_C,
        NormalizationForm_KD,
        NormalizationForm_KC
    };
    QString normalized(NormalizationForm mode) const;
    QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const;

    const ushort *utf16() const;

    QByteArray toAscii() const;
    QByteArray toLatin1() const;
    QByteArray toUtf8() const;
    QByteArray toLocal8Bit() const;

    static QString fromAscii(const char *, int size = -1);
    static QString fromLatin1(const char *, int size = -1);
    static QString fromUtf8(const char *, int size = -1);
    static QString fromLocal8Bit(const char *, int size = -1);
    static QString fromUtf16(const ushort *, int size = -1);
    static QString fromRawData(const QChar *, int size);

    QString &setUnicode(const QChar *unicode, int size);
    inline QString &setUtf16(const ushort *utf16, int size);

    int compare(const QString &s) const;
    static inline int compare(const QString &s1, const QString &s2)
    { return s1.compare(s2); }
    int localeAwareCompare(const QString& s) const;
    static int localeAwareCompare(const QString& s1, const QString& s2)
    { return s1.localeAwareCompare(s2); }

    short  toShort(bool *ok=0, int base=10) const;
    ushort toUShort(bool *ok=0, int base=10) const;
    int toInt(bool *ok=0, int base=10) const;
    uint toUInt(bool *ok=0, int base=10) const;
    long toLong(bool *ok=0, int base=10) const;
    ulong toULong(bool *ok=0, int base=10) const;
    qlonglong toLongLong(bool *ok=0, int base=10) const;
    qulonglong toULongLong(bool *ok=0, int base=10) const;
    float toFloat(bool *ok=0) const;
    double toDouble(bool *ok=0) const;

    QString &setNum(short, int base=10);
    QString &setNum(ushort, int base=10);
    QString &setNum(int, int base=10);
    QString &setNum(uint, int base=10);
    QString &setNum(long, int base=10);
    QString &setNum(ulong, int base=10);
    QString &setNum(qlonglong, int base=10);
    QString &setNum(qulonglong, int base=10);
    QString &setNum(float, char f='g', int prec=6);
    QString &setNum(double, char f='g', int prec=6);

    static QString number(int, int base=10);
    static QString number(uint, int base=10);
    static QString number(long, int base=10);
    static QString number(ulong, int base=10);
    static QString number(qlonglong, int base=10);
    static QString number(qulonglong, int base=10);
    static QString number(double, char f='g', int prec=6);

    bool operator==(const QString &s) const;
    bool operator<(const QString &s) const;
    inline bool operator>(const QString &s) const { return s < *this; }
    inline bool operator!=(const QString &s) const { return !operator==(s); }
    inline bool operator<=(const QString &s) const { return !operator>(s); }
    inline bool operator>=(const QString &s) const { return !operator<(s); }

    bool operator==(const QLatin1String &s) const;
    bool operator<(const QLatin1String &s) const;
    bool operator>(const QLatin1String &s) const;
    inline bool operator!=(const QLatin1String &s) const { return !operator==(s); }
    inline bool operator<=(const QLatin1String &s) const { return !operator>(s); }
    inline bool operator>=(const QLatin1String &s) const { return !operator<(s); }

    

    inline QString(const char *ch) : d(&shared_null)
    { d->ref.ref(); *this = fromAscii(ch); }
    inline QString(const QByteArray &a) : d(&shared_null)
    { d->ref.ref(); *this = fromAscii(a); }
    inline QString &operator=(const char *ch)
    { return (*this = fromAscii(ch)); }
    inline QString &operator=(const QByteArray &a)
    { return (*this = fromAscii(a)); }
    inline QString &operator=(char c)
    { return (*this = QChar(c)); }

    
    inline QString &prepend(const char *s)
    { return prepend(QString::fromAscii(s)); }
    inline QString &prepend(const QByteArray &s)
    { return prepend(QString(s)); }
    inline QString &append(const char *s)
    { return append(QString::fromAscii(s)); }
    inline QString &append(const QByteArray &s)
    { return append(QString(s)); }
    inline QString &operator+=(const char *s)
    { return append(QString::fromAscii(s)); }
    inline QString &operator+=(const QByteArray &s)
    { return append(QString(s)); }
    inline QString &operator+=(char c)
    { return append(QChar(c)); }

    inline bool operator==(const char *s) const;
    inline bool operator!=(const char *s) const;
    inline bool operator<(const char *s) const;
    inline bool operator<=(const char *s2) const;
    inline bool operator>(const char *s2) const;
    inline bool operator>=(const char *s2) const;

    inline bool operator==(const QByteArray &s) const { return (*this == s.constData()); }
    inline bool operator!=(const QByteArray &s) const { return !(*this == s.constData()); }
    inline bool operator<(const QByteArray &s) const { return *this < s.constData(); }
    inline bool operator>(const QByteArray &s) const { return *this > s.constData(); }
    inline bool operator<=(const QByteArray &s) const { return *this <= s.constData(); }
    inline bool operator>=(const QByteArray &s) const { return *this >= s.constData(); }


    typedef QChar *iterator;
    typedef const QChar *const_iterator;
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    iterator begin();
    const_iterator begin() const;
    const_iterator constBegin() const;
    iterator end();
    const_iterator end() const;
    const_iterator constEnd() const;

    
    inline void push_back(QChar c) { append(c); }
    inline void push_back(const QString &s) { append(s); }
    inline void push_front(QChar c) { prepend(c); }
    inline void push_front(const QString &s) { prepend(s); }


    static inline QString fromStdString(const std::string &s);
    inline std::string toStdString() const;





    static inline QString fromStdWString(const QStdWString &s);
    inline QStdWString toStdWString() const;




    
    struct Null { };
    static const Null null;
    inline QString(const Null &): d(&shared_null) { d->ref.ref(); }
    inline QString &operator=(const Null &) { *this = QString(); return *this; }
    inline bool isNull() const { return d == &shared_null; }


    inline  const char *ascii() const { return ascii_helper(); }
    inline  const char *latin1() const { return latin1_helper(); }
    inline  QByteArray utf8() const { return toUtf8(); }
    inline  QByteArray local8Bit() const{ return toLocal8Bit(); }
    inline  void setLength(int nl) { resize(nl); }
    inline  QString copy() const { return *this; }
    inline  QString &remove(QChar c, bool cs)
    { return remove(c, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    inline  QString &remove(const QString  &s, bool cs)
    { return remove(s, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    inline  QString &replace(QChar c, const QString  &after, bool cs)
    { return replace(c, after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    inline  QString &replace(const QString &before, const QString &after, bool cs)
    { return replace(before, after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }

    inline  QString &replace(char c, const QString &after, bool cs)
    { return replace(QChar(c), after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    
    inline  QString &replace(char c, const QString &after, Qt::CaseSensitivity cs)
    { return replace(QChar(c), after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }

    inline  int find(QChar c, int i = 0, bool cs = true) const
    { return indexOf(c, i, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    inline  int find(const QString &s, int i = 0, bool cs = true) const
    { return indexOf(s, i, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    inline  int findRev(QChar c, int i = -1, bool cs = true) const
    { return lastIndexOf(c, i, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    inline  int findRev(const QString &s, int i = -1, bool cs = true) const
    { return lastIndexOf(s, i, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }

    inline  int find(const QRegExp &rx, int i=0) const
    { return indexOf(rx, i); }
    inline  int findRev(const QRegExp &rx, int i=-1) const
    { return lastIndexOf(rx, i); }

    inline  QBool contains(QChar c, bool cs) const
    { return contains(c, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    inline  QBool contains(const QString &s, bool cs) const
    { return contains(s, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    inline  bool startsWith(const QString &s, bool cs) const
    { return startsWith(s, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    inline  bool endsWith(const QString &s, bool cs) const
    { return endsWith(s, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
    inline  QChar constref(uint i) const
    { return at(i); }
     QChar &ref(uint i);
    inline  QString leftJustify(int width, QChar fill = QLatin1Char(' '), bool trunc=false) const
    { return leftJustified(width, fill, trunc); }
    inline  QString rightJustify(int width, QChar fill = QLatin1Char(' '), bool trunc=false) const
    { return rightJustified(width, fill, trunc); }
    inline  QString lower() const { return toLower(); }
    inline  QString upper() const { return toUpper(); }
    inline  QString stripWhiteSpace() const { return trimmed(); }
    inline  QString simplifyWhiteSpace() const { return simplified(); }
    inline  QString &setUnicodeCodes(const ushort *unicode_as_ushorts, int size)
    { return setUtf16(unicode_as_ushorts, size); }
    inline  const ushort *ucs2() const { return utf16(); }
    inline static  QString fromUcs2(const ushort *unicode, int size = -1)
    { return fromUtf16(unicode, size); }
    inline  QString &setAscii(const char *str, int len = -1)
    { *this = fromAscii(str, len); return *this; }
    inline  QString &setLatin1(const char *str, int len = -1)
    { *this = fromLatin1(str, len); return *this; }
protected:
    friend class QObject;
    const char *ascii_helper() const;
    const char *latin1_helper() const;
public:
#line 460 "../../include/QtCore/../../src/corelib/tools/qstring.h"

    bool isSimpleText() const { if (!d->clean) updateProperties(); return d->simpletext; }
    bool isRightToLeft() const { if (!d->clean) updateProperties(); return d->righttoleft; }

private:
#line 473 "../../include/QtCore/../../src/corelib/tools/qstring.h"

    struct Data {
        QBasicAtomic ref;
        int alloc, size;
        ushort *data;
        ushort clean : 1;
        ushort simpletext : 1;
        ushort righttoleft : 1;
        ushort asciiCache : 1;
        ushort reserved : 12;
        ushort array[1];
    };
    static Data shared_null;
    static Data shared_empty;
    Data *d;
    QString(Data *dd, int  ) : d(dd) {}

    static QTextCodec *codecForCStrings;

    static int grow(int);
    static void free(Data *);
    void realloc();
    void realloc(int alloc);
    void expand(int i);
    void updateProperties() const;
    QString multiArg(int numArgs, const QString **args) const;

    int toWCharArray(wchar_t *array) const;
    static QString fromWCharArray(const wchar_t *, int);

    static Data *fromLatin1_helper(const char *str, int size = -1);
    friend class QCharRef;
    friend class QTextCodec;
};


class  QLatin1String
{
public:
    inline explicit QLatin1String(const char *s) : chars(s) {}
    inline QLatin1String &operator=(const QLatin1String &other)
    { chars = other.chars; return *this; }

    inline const char *latin1() const { return chars; }

    inline bool operator==(const QString &s) const
    { return s == *this; }
    inline bool operator!=(const QString &s) const
    { return s != *this; }
    inline bool operator>(const QString &s) const
    { return s < *this; }
    inline bool operator<(const QString &s) const
    { return s > *this; }
    inline bool operator>=(const QString &s) const
    { return s <= *this; }
    inline bool operator<=(const QString &s) const
    { return s >= *this; }

private:
    const char *chars;
};


inline QString::QString(const QLatin1String &latin1) : d(fromLatin1_helper(latin1.latin1()))
{ }
inline int QString::length() const
{ return d->size; }
inline const QChar QString::at(int i) const
{ do {if(!(i >= 0 && i < size()))qt_assert("i >= 0 && i < size()","../../include/QtCore/../../src/corelib/tools/qstring.h",541);} while (0); return d->data[i]; }
inline const QChar QString::operator[](int i) const
{ do {if(!(i >= 0 && i < size()))qt_assert("i >= 0 && i < size()","../../include/QtCore/../../src/corelib/tools/qstring.h",543);} while (0); return d->data[i]; }
inline const QChar QString::operator[](uint i) const
{ do {if(!(i < uint(size())))qt_assert("i < uint(size())","../../include/QtCore/../../src/corelib/tools/qstring.h",545);} while (0); return d->data[i]; }
inline bool QString::isEmpty() const
{ return d->size == 0; }
inline const QChar *QString::unicode() const
{ return reinterpret_cast<const QChar*>(d->data); }
inline const QChar *QString::data() const
{ return reinterpret_cast<const QChar*>(d->data); }
inline QChar *QString::data()
{ detach(); return reinterpret_cast<QChar*>(d->data); }
inline const QChar *QString::constData() const
{ return reinterpret_cast<const QChar*>(d->data); }
inline void QString::detach()
{ if (d->ref != 1 || d->data != d->array) realloc(); }
inline bool QString::isDetached() const
{ return d->ref == 1; }
inline QString &QString::operator=(const QLatin1String &s)
{
    *this = fromLatin1(s.latin1());
    return *this;
}
inline void QString::clear()
{ if (!isNull()) *this = QString(); }
inline QString::QString(const QString &s) : d(s.d)
{ do {if(!(&s != this))qt_assert("&s != this","../../include/QtCore/../../src/corelib/tools/qstring.h",568);} while (0); d->ref.ref(); }
inline int QString::capacity() const
{ return d->alloc; }
inline QString &QString::setNum(short n, int base)
{ return setNum(qlonglong(n), base); }
inline QString &QString::setNum(ushort n, int base)
{ return setNum(qulonglong(n), base); }
inline QString &QString::setNum(int n, int base)
{ return setNum(qlonglong(n), base); }
inline QString &QString::setNum(uint n, int base)
{ return setNum(qulonglong(n), base); }
inline QString &QString::setNum(long n, int base)
{ return setNum(qlonglong(n), base); }
inline QString &QString::setNum(ulong n, int base)
{ return setNum(qulonglong(n), base); }
inline QString &QString::setNum(float n, char f, int prec)
{ return setNum(double(n),f,prec); }
inline QString QString::arg(int a, int fieldWidth, int base, const QChar &fillChar) const
{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(uint a, int fieldWidth, int base, const QChar &fillChar) const
{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(long a, int fieldWidth, int base, const QChar &fillChar) const
{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(ulong a, int fieldWidth, int base, const QChar &fillChar) const
{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(short a, int fieldWidth, int base, const QChar &fillChar) const
{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(ushort a, int fieldWidth, int base, const QChar &fillChar) const
{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(const QString &a1, const QString &a2) const
{ const QString *args[2] = { &a1, &a2 }; return multiArg(2, args); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3) const
{ const QString *args[3] = { &a1, &a2, &a3 }; return multiArg(3, args); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4) const
{ const QString *args[4] = { &a1, &a2, &a3, &a4 }; return multiArg(4, args); }
inline QString QString::section(QChar asep, int astart, int aend, SectionFlags aflags) const
{ return section(QString(asep), astart, aend, aflags); }


class  QCharRef {
    QString &s;
    int i;
    inline QCharRef(QString &str, int idx)
        : s(str),i(idx) {}
    friend class QString;
public:

    

    
    inline operator QChar() const
        { return i < s.d->size ? s.d->data[i] : 0; }
    inline QCharRef &operator=(const QChar &c)
        { if (s.d->ref != 1 || i >= s.d->size) s.expand(i);
          s.d->data[i] = c.unicode();  return *this; }

    

    inline QCharRef &operator=(char c) { return operator=(QChar(c)); }
    inline QCharRef &operator=(uchar c) { return operator=(QChar(c)); }

    inline QCharRef &operator=(const QCharRef &c) { return operator=(QChar(c)); }
    inline QCharRef &operator=(ushort rc) { return operator=(QChar(rc)); }
    inline QCharRef &operator=(short rc) { return operator=(QChar(rc)); }
    inline QCharRef &operator=(uint rc) { return operator=(QChar(rc)); }
    inline QCharRef &operator=(int rc) { return operator=(QChar(rc)); }

    
    inline bool isNull() const { return QChar(*this).isNull(); }
    inline bool isPrint() const { return QChar(*this).isPrint(); }
    inline bool isPunct() const { return QChar(*this).isPunct(); }
    inline bool isSpace() const { return QChar(*this).isSpace(); }
    inline bool isMark() const { return QChar(*this).isMark(); }
    inline bool isLetter() const { return QChar(*this).isLetter(); }
    inline bool isNumber() const { return QChar(*this).isNumber(); }
    inline bool isLetterOrNumber() { return QChar(*this).isLetterOrNumber(); }
    inline bool isDigit() const { return QChar(*this).isDigit(); }

    inline int digitValue() const { return QChar(*this).digitValue(); }
    QChar toLower() const { return QChar(*this).toLower(); }
    QChar toUpper() const { return QChar(*this).toUpper(); }

    inline  QChar lower() const { return QChar(*this).toLower(); }
    inline  QChar upper() const { return QChar(*this).toUpper(); }


    QChar::Category category() const { return QChar(*this).category(); }
    QChar::Direction direction() const { return QChar(*this).direction(); }
    QChar::Joining joining() const { return QChar(*this).joining(); }
    bool hasMirrored() const { return QChar(*this).hasMirrored(); }

    inline bool  mirrored() const { return hasMirrored(); }

    QChar mirroredChar() const { return QChar(*this).mirroredChar(); }
    QString decomposition() const { return QChar(*this).decomposition(); }
    QChar::Decomposition decompositionTag() const { return QChar(*this).decompositionTag(); }
    uchar combiningClass() const { return QChar(*this).combiningClass(); }

    QChar::UnicodeVersion unicodeVersion() const { return QChar(*this).unicodeVersion(); }

    inline uchar cell() const { return QChar(*this).cell(); }
    inline uchar row() const { return QChar(*this).row(); }
    inline void setCell(uchar cell);
    inline void setRow(uchar row);

    const char toAscii() const { return QChar(*this).toAscii(); }
    const char toLatin1() const { return QChar(*this).toLatin1(); }

    const char latin1() const { return QChar(*this).toLatin1(); }
    const char ascii() const { return QChar(*this).toAscii(); }

    const ushort unicode() const { return QChar(*this).unicode(); }
};

inline void QCharRef::setRow(uchar arow) { QChar(*this).setRow(arow); }
inline void QCharRef::setCell(uchar acell) { QChar(*this).setCell(acell); }


inline QString::QString() : d(&shared_null) { d->ref.ref(); }
inline QString::~QString() { if (!d->ref.deref()) free(d); }
inline void QString::reserve(int asize) { if (d->ref != 1 || asize > d->alloc) realloc(asize); }
inline QString &QString::setUtf16(const ushort *autf16, int asize)
{ return setUnicode(reinterpret_cast<const QChar *>(autf16), asize); }
inline QCharRef QString::operator[](int i)
{ do {if(!(i >= 0))qt_assert("i >= 0","../../include/QtCore/../../src/corelib/tools/qstring.h",692);} while (0); return QCharRef(*this, i); }
inline QCharRef QString::operator[](uint i)
{ return QCharRef(*this, i); }
inline QString::iterator QString::begin()
{ detach(); return reinterpret_cast<QChar*>(d->data); }
inline QString::const_iterator QString::begin() const
{ return reinterpret_cast<const QChar*>(d->data); }
inline QString::const_iterator QString::constBegin() const
{ return reinterpret_cast<const QChar*>(d->data); }
inline QString::iterator QString::end()
{ detach(); return reinterpret_cast<QChar*>(d->data + d->size); }
inline QString::const_iterator QString::end() const
{ return reinterpret_cast<const QChar*>(d->data + d->size); }
inline QString::const_iterator QString::constEnd() const
{ return reinterpret_cast<const QChar*>(d->data + d->size); }
inline QBool QString::contains(const QString &s, Qt::CaseSensitivity cs) const
{ return QBool(indexOf(s, 0, cs) != -1); }
inline QBool QString::contains(QChar c, Qt::CaseSensitivity cs) const
{ return QBool(indexOf(c, 0, cs) != -1); }


inline bool operator==(QString::Null, QString::Null) { return true; }
inline bool operator==(QString::Null, const QString &s) { return s.isNull(); }
inline bool operator==(const QString &s, QString::Null) { return s.isNull(); }
inline bool operator!=(QString::Null, QString::Null) { return false; }
inline bool operator!=(QString::Null, const QString &s) { return !s.isNull(); }
inline bool operator!=(const QString &s, QString::Null) { return !s.isNull(); }


inline bool QString::operator==(const char *s) const {

    if (codecForCStrings) return (*this == QString::fromAscii(s));

    return (*this == QLatin1String(s));
}
inline bool QString::operator!=(const char *s) const{ return !(*this == s); }
inline bool QString::operator<(const char *s) const { return *this < QString::fromAscii(s); }
inline bool QString::operator>(const char *s) const { return *this > QString::fromAscii(s); }
inline bool QString::operator<=(const char *s) const { return *this <= QString::fromAscii(s); }
inline bool QString::operator>=(const char *s) const { return *this >= QString::fromAscii(s); }

inline bool operator==(const char *s1, const QString &s2) { return (s2 == s1); }
inline bool operator!=(const char *s1, const QString &s2) { return !(s2 == s1); }
inline bool operator<(const char *s1, const QString &s2) { return (QString::fromAscii(s1) < s2); }
inline bool operator>(const char *s1, const QString &s2) { return (QString::fromAscii(s1) > s2); }
inline bool operator<=(const char *s1, const QString &s2) { return (QString::fromAscii(s1) <= s2); }
inline bool operator>=(const char *s1, const QString &s2) { return (QString::fromAscii(s1) >= s2); }

inline bool QByteArray::operator==(const QString &s) const { return constData() == s; }
inline bool QByteArray::operator!=(const QString &s) const { return !(constData() == s); }
inline bool QByteArray::operator<(const QString &s) const { return constData() < s; }
inline bool QByteArray::operator>(const QString &s) const { return constData() > s; }
inline bool QByteArray::operator<=(const QString &s) const { return constData() <= s; }
inline bool QByteArray::operator>=(const QString &s) const { return constData() >= s; }


#line 772 "../../include/QtCore/../../src/corelib/tools/qstring.h"

inline const QString operator+(const QString &s1, const QString &s2)
{ QString t(s1); t += s2; return t; }
inline const QString operator+(const QString &s1, QChar s2)
{ QString t(s1); t += s2; return t; }
inline const QString operator+(QChar s1, const QString &s2)
{ QString t(s1); t += s2; return t; }

inline const QString operator+(const QString &s1, const char *s2)
{ QString t(s1); t += QString::fromAscii(s2); return t; }
inline const QString operator+(const char *s1, const QString &s2)
{ QString t(s1); t += s2; return t; }
inline const QString operator+(char c, const QString &s)
{ QString t = s; t.prepend(QChar(c)); return t; }
inline const QString operator+(const QString &s, char c)
{ QString t(s); t += c; return t; }
inline const QString operator+(const QByteArray &ba, const QString &s)
{ QString t(ba); t += s; return t; }
inline const QString operator+(const QString &s, const QByteArray &ba)
{ QString t(s); t += ba; return t; }



inline std::string QString::toStdString() const
{ const QByteArray asc = toAscii(); return std::string(asc.constData(), asc.length()); }

inline QString QString::fromStdString(const std::string &s)
{ return fromAscii(s.data(), int(s.size())); }


inline QStdWString QString::toStdWString() const
{
    QStdWString str;
    str.resize(length());







    str.resize(toWCharArray(&(*str.begin())));
    return str;
}
inline QString QString::fromStdWString(const QStdWString &s)
{ return fromWCharArray(s.data(), int(s.size())); }




inline QChar &QString::ref(uint i)
{
    if (int(i) > d->size || d->ref != 1)
        resize(qMax(int(i), d->size));
    return reinterpret_cast<QChar&>(d->data[i]);
}



 QDataStream &operator<<(QDataStream &, const QString &);
 QDataStream &operator>>(QDataStream &, QString &);



class QConstString : public QString
{
public:
    inline explicit QConstString(const QChar *unicode, int size)
        :QString(unicode, size){} 
    inline  const QString &string() const { return *this; }
};


template <> class QTypeInfo<QString> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QString)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QString"; } };
template <> inline bool qIsDetached<QString>(QString &t) { return t . isDetached(); }
inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QString::SectionFlags::enum_type f2) { return QFlags<QString::SectionFlags::enum_type>(f1) | f2; } inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QFlags<QString::SectionFlags::enum_type> f2) { return f2 | f1; }









#line 2 "../../include/QtCore/qstring.h"
#line 29 "../../include/QtCore/../../src/corelib/kernel/qobject.h"
#line 1 "../../include/QtCore/qbytearray.h"
#line 30 "../../include/QtCore/../../src/corelib/kernel/qobject.h"
#line 1 "../../include/QtCore/qlist.h"
#line 31 "../../include/QtCore/../../src/corelib/kernel/qobject.h"






typedef QtValidLicenseForCoreModule QtCoreModule;

class QEvent;
class QTimerEvent;
class QChildEvent;
struct QMetaObject;
class QVariant;
class QObjectPrivate;
class QObject;
class QThread;
class QWidget;

class QRegExp;


class QObjectUserData;


typedef QList<QObject*> QObjectList;

#line 64 "../../include/QtCore/../../src/corelib/kernel/qobject.h"
template<typename T> inline T qFindChild(const QObject *, const QString & = QString());
template<typename T> inline QList<T> qFindChildren(const QObject *, const QString & = QString());

template<typename T> inline QList<T> qFindChildren(const QObject *, const QRegExp &);



class QObjectData {
public:
    virtual ~QObjectData() = 0;
    QObject *q_ptr;
    QObject *parent;
    QObjectList children;

    uint isWidget : 1;
    uint pendTimer : 1;
    uint blockSig : 1;
    uint wasDeleted : 1;
    uint ownObjectName : 1;
    uint sendChildEvents : 1;
    uint receiveChildEvents : 1;
    uint unused : 25;
    int postedEvents;

    int postedChildInsertedEvents;



};


class  QObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:
    
    inline QObjectPrivate* d_func() { return reinterpret_cast<QObjectPrivate * >(d_ptr); } inline const QObjectPrivate* d_func() const { return reinterpret_cast<const QObjectPrivate * >(d_ptr); } friend class QObjectPrivate;

public:
    explicit QObject(QObject *parent=0);
    virtual ~QObject();

    virtual bool event(QEvent *);
    virtual bool eventFilter(QObject *, QEvent *);

#line 121 "../../include/QtCore/../../src/corelib/kernel/qobject.h"

    QString objectName() const;
    void setObjectName(const QString &name);

    inline bool isWidgetType() const { return d_ptr->isWidget; }

    inline bool signalsBlocked() const { return d_ptr->blockSig; }
    bool blockSignals(bool b);

    QThread *thread() const;
    void moveToThread(QThread *thread);

    int startTimer(int interval);
    void killTimer(int id);


    template<typename T>
    inline T findChild(const QString &name = QString()) const
    { return qFindChild<T>(this, name); }

    template<typename T>
    inline QList<T> findChildren(const QString &name = QString()) const
    { return qFindChildren<T>(this, name); }


    template<typename T>
    inline QList<T> findChildren(const QRegExp &re) const
    { return qFindChildren<T>(this, re); }




     QObject *child(const char *objName, const char *inheritsClass = 0,
                   bool recursiveSearch = true) const;
     QObjectList queryList(const char *inheritsClass = 0,
                          const char *objName = 0,
                          bool regexpMatch = true,
                          bool recursiveSearch = true) const;

    inline const QObjectList &children() const { return d_ptr->children; }

    void setParent(QObject *);
    void installEventFilter(QObject *);
    void removeEventFilter(QObject *);


    static bool connect(const QObject *sender, const char *signal,
                        const QObject *receiver, const char *member, Qt::ConnectionType =

                        Qt::AutoCompatConnection



        );
    inline bool connect(const QObject *sender, const char *signal,
                        const char *member, Qt::ConnectionType type =

                        Qt::AutoCompatConnection



        ) const;

    static bool disconnect(const QObject *sender, const char *signal,
                           const QObject *receiver, const char *member);
    inline bool disconnect(const char *signal = 0,
                           const QObject *receiver = 0, const char *member = 0)
        { return disconnect(this, signal, receiver, member); }
    inline bool disconnect(const QObject *receiver, const char *member = 0)
        { return disconnect(this, 0, receiver, member); }

    void dumpObjectTree();
    void dumpObjectInfo();


    bool setProperty(const char *name, const QVariant &value);
    QVariant property(const char *name) const;



    static uint registerUserData();
    void setUserData(uint id, QObjectUserData* data);
    QObjectUserData* userData(uint id) const;


protected:
    void destroyed(QObject * = 0);

public:
    inline QObject *parent() const { return d_ptr->parent; }

    inline bool inherits(const char *classname) const
        { return const_cast<QObject *>(this)->qt_metacast(classname) != 0; }

public :
    void deleteLater();

protected:
    QObject *sender() const;
    int receivers(const char* signal) const;

    virtual void timerEvent(QTimerEvent *);
    virtual void childEvent(QChildEvent *);
    virtual void customEvent(QEvent *);

    virtual void connectNotify(const char *signal);
    virtual void disconnectNotify(const char *signal);


public:
    explicit QObject(QObject *parent, const char *name);
    inline  void insertChild(QObject *o)
        { if (o) o->setParent(this); }
    inline  void removeChild(QObject *o)
        { if (o) o->setParent(0); }
    inline  bool isA(const char *classname) const
        { return qstrcmp(classname, metaObject()->className()) == 0; }
    inline  const char *className() const { return metaObject()->className(); }
    inline  const char *name() const { return objectName().latin1_helper(); }
    inline  const char *name(const char *defaultName) const
        { QString s = objectName(); return s.isEmpty()?defaultName:s.latin1_helper(); }
    inline  void setName(const char *name) { setObjectName(QLatin1String(name)); }
protected:
    inline  bool checkConnectArgs(const char *signal,
                                  const QObject *,
                                  const char *member)
        { return QMetaObject::checkConnectArgs(signal, member); }
    static inline  QByteArray normalizeSignalSlot(const char *signalSlot)
        { return QMetaObject::normalizedSignature(signalSlot); }


protected:
    QObject(QObjectPrivate &dd, QObject *parent = 0);

protected:
    QObjectData *d_ptr;

    static const QMetaObject staticQtMetaObject;

    friend struct QMetaObject;
    friend class QApplication;
    friend class QApplicationPrivate;
    friend class QCoreApplication;
    friend class QCoreApplicationPrivate;
    friend class QWidget;
    friend class QThreadData;

private:
    QObject(const QObject &); QObject &operator=(const QObject &);
    
};

inline bool QObject::connect(const QObject *asender, const char *asignal,
                             const char *amember, Qt::ConnectionType atype) const
{ return connect(asender, asignal, this, amember, atype); }


class  QObjectUserData {
public:
    virtual ~QObjectUserData();
};



 void qt_qFindChildren_helper(const QObject *parent, const QString &name, const QRegExp *re,
                         const QMetaObject &mo, QList<void*> *list);
 QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo);


#line 358 "../../include/QtCore/../../src/corelib/kernel/qobject.h"

template<typename T>
inline T qFindChild(const QObject *o, const QString &name)
{ return static_cast<T>(qt_qFindChild_helper(o, name, reinterpret_cast<T>(0)->staticMetaObject)); }

template<typename T>
inline QList<T> qFindChildren(const QObject *o, const QString &name)
{
    QList<T> list;
    qt_qFindChildren_helper(o, name, 0, reinterpret_cast<T>(0)->staticMetaObject,
                         reinterpret_cast<QList<void *>*>(&list));
    return list;
}


template<typename T>
inline QList<T> qFindChildren(const QObject *o, const QRegExp &re)
{
    QList<T> list;
    qt_qFindChildren_helper(o, 0, &re, reinterpret_cast<T>(0)->staticMetaObject,
                        reinterpret_cast<QList<void*>*>(&list));
    return list;
}


template <class T>
inline T qobject_cast(QObject *object)
{ return static_cast<T>(reinterpret_cast<T>(0)->staticMetaObject.cast(object)); }

template <class T>
inline T qobject_cast(const QObject *object)
{ return static_cast<T>(const_cast<const QObject *>(reinterpret_cast<T>(0)->staticMetaObject.cast(const_cast<QObject *>(object)))); }











 QDebug operator<<(QDebug, const QObject *);






#line 2 "../../include/QtCore/qobject.h"
#line 27 "../../include/QtCore/../../src/corelib/io/qiodevice.h"
#line 1 "../../include/QtCore/qstring.h"
#line 31 "../../include/QtCore/../../src/corelib/io/qiodevice.h"







typedef QtValidLicenseForCoreModule QtCoreModule;

class QByteArray;
class QIODevicePrivate;

class  QIODevice

    : public QObject

{

    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:

public:
    enum OpenModeFlag {
        NotOpen = 0x0000,
        ReadOnly = 0x0001,
        WriteOnly = 0x0002,
        ReadWrite = ReadOnly | WriteOnly,
        Append = 0x0004,
        Truncate = 0x0008,
        Text = 0x0010,
        Unbuffered = 0x0020
    };
    typedef QFlags<OpenModeFlag> OpenMode;

    QIODevice();

    explicit QIODevice(QObject *parent);

    virtual ~QIODevice();

    OpenMode openMode() const;

    void setTextModeEnabled(bool enabled);
    bool isTextModeEnabled() const;

    bool isOpen() const;
    bool isReadable() const;
    bool isWritable() const;
    virtual bool isSequential() const;

    virtual bool open(OpenMode mode);
    virtual void close();

    virtual qint64 pos() const;
    virtual qint64 size() const;
    virtual bool seek(qint64 pos);
    virtual bool atEnd() const;
    virtual bool reset();

    virtual qint64 bytesAvailable() const;
    virtual qint64 bytesToWrite() const;

    qint64 read(char *data, qint64 maxlen);
    QByteArray read(qint64 maxlen);
    QByteArray readAll();
    qint64 readLine(char *data, qint64 maxlen);
    QByteArray readLine(qint64 maxlen = 0);
    virtual bool canReadLine() const;

    qint64 write(const char *data, qint64 len);
    inline qint64 write(const QByteArray &data)
    { return write(data.constData(), data.size()); }

    qint64 peek(char *data, qint64 maxlen);
    QByteArray peek(qint64 maxlen);

    virtual bool waitForReadyRead(int msecs);
    virtual bool waitForBytesWritten(int msecs);

    void ungetChar(char c);
    inline bool putChar(char c) { return write(&c, 1) == 1; }
    inline bool getChar(char *c)
    { char ch; bool result = read(&ch, 1) == 1; if (c) *c = ch; return result; }

    QString errorString() const;


protected:
    void readyRead();
    void bytesWritten(qint64 bytes);
    void aboutToClose();


protected:



    QIODevice(QIODevicePrivate &dd, QObject *parent = 0);

    virtual qint64 readData(char *data, qint64 maxlen) = 0;
    virtual qint64 readLineData(char *data, qint64 maxlen);
    virtual qint64 writeData(const char *data, qint64 len) = 0;

    void setOpenMode(OpenMode openMode);

    void setErrorString(const QString &errorString);





private:
    inline QIODevicePrivate* d_func() { return reinterpret_cast<QIODevicePrivate * >(d_ptr); } inline const QIODevicePrivate* d_func() const { return reinterpret_cast<const QIODevicePrivate * >(d_ptr); } friend class QIODevicePrivate;
    QIODevice(const QIODevice &); QIODevice &operator=(const QIODevice &);


public:
    typedef qint64 Offset;

    inline  int flags() const { return (int) openMode(); }
    inline  int mode() const { return (int) openMode(); }
    inline  int state() const;

    inline  bool isDirectAccess() const { return !isSequential(); }
    inline  bool isSequentialAccess() const { return isSequential(); }
    inline  bool isCombinedAccess() const { return false; }
    inline  bool isBuffered() const { return true; }
    inline  bool isRaw() const { return false; }
    inline  bool isSynchronous() const { return true; }
    inline  bool isAsynchronous() const { return false; }
    inline  bool isTranslated() const { return (openMode() & Text) != 0; }
    inline  bool isInactive() const { return !isOpen(); }

    typedef int Status;
     Status status() const;
     void resetStatus();

    inline  Offset at() const { return pos(); }
    inline  bool at(Offset offset) { return seek(offset); }

    inline  qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
    inline  qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
    inline  qint64 writeBlock(const QByteArray &data) { return write(data); }

    inline  int getch() { char c; return getChar(&c) ? int(uchar(c)) : -1; }
    inline  int putch(int c) { return putChar(c) ? int(uchar(c)) : -1; }
    inline  int ungetch(int c) { ungetChar(uchar(c)); return c; }

};

inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QIODevice::OpenMode::enum_type f2) { return QFlags<QIODevice::OpenMode::enum_type>(f1) | f2; } inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QFlags<QIODevice::OpenMode::enum_type> f2) { return f2 | f1; }


static  const uint IO_Direct = 0x0100;
static  const uint IO_Sequential = 0x0200;
static  const uint IO_Combined = 0x0300;
static  const uint IO_TypeMask = 0x0300;

static  const uint IO_Raw = 0x0000;
static  const uint IO_Async = 0x0000;

#line 198 "../../include/QtCore/../../src/corelib/io/qiodevice.h"

static  const uint IO_Open = 0x1000;
static  const uint IO_StateMask = 0xf000;

static  const uint IO_Ok = 0;
static  const uint IO_ReadError = 1;
static  const uint IO_WriteError = 2;
static  const uint IO_FatalError = 3;
static  const uint IO_ResourceError = 4;
static  const uint IO_OpenError = 5;
static  const uint IO_ConnectError = 5;
static  const uint IO_AbortError = 6;
static  const uint IO_TimeOutError = 7;
static  const uint IO_UnspecifiedError	= 8;

inline  int QIODevice::state() const
{
    return isOpen() ? 0x1000 : 0;
}



class QDebug;
 QDebug operator<<(QDebug debug, QIODevice::OpenMode modes);




#line 2 "../../include/QtCore/qiodevice.h"
#line 26 "../../include/QtCore/../../src/corelib/io/qdatastream.h"
#line 1 "../../include/QtCore/qglobal.h"
#line 27 "../../include/QtCore/../../src/corelib/io/qdatastream.h"







typedef QtValidLicenseForCoreModule QtCoreModule;

class QByteArray;
class QIODevice;

template <typename T> class QList;
template <typename T> class QLinkedList;
template <typename T> class QVector;
template <typename T> class QSet;
template <class Key, class T> class QHash;
template <class Key, class T> class QMap;

class QDataStreamPrivate;


class  QDataStream
{
public:
    enum Version {
        Qt_1_0 = 1,
        Qt_2_0 = 2,
        Qt_2_1 = 3,
        Qt_3_0 = 4,
        Qt_3_1 = 5,
        Qt_3_3 = 6,
        Qt_4_0 = 7,
        Qt_4_1 = Qt_4_0



    };

    enum ByteOrder {
        BigEndian = QSysInfo::BigEndian,
        LittleEndian = QSysInfo::LittleEndian
    };

    enum Status {
        Ok,
        ReadPastEnd,
	ReadCorruptData
    };

    QDataStream();
    explicit QDataStream(QIODevice *);

    QDataStream(QByteArray *, int mode);

    QDataStream(QByteArray *, QIODevice::OpenMode flags);
    QDataStream(const QByteArray &);
    virtual ~QDataStream();

    QIODevice *device() const;
    void setDevice(QIODevice *);
    void unsetDevice();

    bool atEnd() const;

    inline  bool eof() const { return atEnd(); }


    Status status() const;
    void setStatus(Status status);
    void resetStatus();

    ByteOrder byteOrder() const;
    void setByteOrder(ByteOrder);

    int version() const;
    void setVersion(int);

    QDataStream &operator>>(qint8 &i);
    QDataStream &operator>>(quint8 &i);
    QDataStream &operator>>(qint16 &i);
    QDataStream &operator>>(quint16 &i);
    QDataStream &operator>>(qint32 &i);
    QDataStream &operator>>(quint32 &i);
    QDataStream &operator>>(qint64 &i);
    QDataStream &operator>>(quint64 &i);

    QDataStream &operator>>(bool &i);
    QDataStream &operator>>(float &f);
    QDataStream &operator>>(double &f);
    QDataStream &operator>>(char *&str);

    QDataStream &operator<<(qint8 i);
    QDataStream &operator<<(quint8 i);
    QDataStream &operator<<(qint16 i);
    QDataStream &operator<<(quint16 i);
    QDataStream &operator<<(qint32 i);
    QDataStream &operator<<(quint32 i);
    QDataStream &operator<<(qint64 i);
    QDataStream &operator<<(quint64 i);
    QDataStream &operator<<(bool i);
    QDataStream &operator<<(float f);
    QDataStream &operator<<(double f);
    QDataStream &operator<<(const char *str);

    QDataStream &readBytes(char *&, uint &len);
    int readRawData(char *, int len);

    QDataStream &writeBytes(const char *, uint len);
    int writeRawData(const char *, int len);

    int skipRawData(int len);


    inline  QDataStream &readRawBytes(char *str, uint len)
        { readRawData(str, (int)len); return *this; }
    inline  QDataStream &writeRawBytes(const char *str, uint len)
        { writeRawData(str, (int)len); return *this; }
    inline  bool isPrintableData() const { return false; }
    inline  void setPrintableData(bool) {}


private:
    QDataStream(const QDataStream &); QDataStream &operator=(const QDataStream &);

    QDataStreamPrivate *d;

    QIODevice *dev;
    bool owndev;
    bool noswap;
    ByteOrder byteorder;
    int ver;
    Status q_status;
};




 

inline QIODevice *QDataStream::device() const
{ return dev; }

inline QDataStream::ByteOrder QDataStream::byteOrder() const
{ return byteorder; }

inline int QDataStream::version() const
{ return ver; }

inline void QDataStream::setVersion(int v)
{ ver = v; }

inline QDataStream &QDataStream::operator>>(quint8 &i)
{ return *this >> reinterpret_cast<qint8&>(i); }

inline QDataStream &QDataStream::operator>>(quint16 &i)
{ return *this >> reinterpret_cast<qint16&>(i); }

inline QDataStream &QDataStream::operator>>(quint32 &i)
{ return *this >> reinterpret_cast<qint32&>(i); }

inline QDataStream &QDataStream::operator>>(quint64 &i)
{ return *this >> reinterpret_cast<qint64&>(i); }

inline QDataStream &QDataStream::operator<<(quint8 i)
{ return *this << qint8(i); }

inline QDataStream &QDataStream::operator<<(quint16 i)
{ return *this << qint16(i); }

inline QDataStream &QDataStream::operator<<(quint32 i)
{ return *this << qint32(i); }

inline QDataStream &QDataStream::operator<<(quint64 i)
{ return *this << qint64(i); }

template <typename T>
QDataStream& operator>>(QDataStream& s, QList<T>& l)
{
    l.clear();
    quint32 c;
    s >> c;
    for(quint32 i = 0; i < c; ++i)
    {
        T t;
        s >> t;
        l.append(t);
        if (s.atEnd())
            break;
    }
    return s;
}

template <typename T>
QDataStream& operator<<(QDataStream& s, const QList<T>& l)
{
    s << quint32(l.size());
    for (int i = 0; i < l.size(); ++i)
        s << l.at(i);
    return s;
}

template <typename T>
QDataStream& operator>>(QDataStream& s, QLinkedList<T>& l)
{
    l.clear();
    quint32 c;
    s >> c;
    for(quint32 i = 0; i < c; ++i)
    {
        T t;
        s >> t;
        l.append(t);
        if (s.atEnd())
            break;
    }
    return s;
}

template <typename T>
QDataStream& operator<<(QDataStream& s, const QLinkedList<T>& l)
{
    s << quint32(l.size());
    typename QLinkedList<T>::ConstIterator it = l.constBegin();
    for(; it != l.constEnd(); ++it)
        s << *it;
    return s;
}

template<typename T>
QDataStream& operator>>(QDataStream& s, QVector<T>& v)
{
    v.clear();
    quint32 c;
    s >> c;
    v.resize(c);
    for(quint32 i = 0; i < c; ++i) {
        T t;
        s >> t;
        v[i] = t;
    }
    return s;
}

template<typename T>
QDataStream& operator<<(QDataStream& s, const QVector<T>& v)
{
    s << quint32(v.size());
    const T* it = v.begin();
    for(; it != v.end(); ++it)
        s << *it;
    return s;
}

template <typename T>
QDataStream &operator>>(QDataStream &in, QSet<T> &set)
{
    set.clear();
    quint32 c;
    in >> c;
    for (quint32 i = 0; i < c; ++i) {
        T t;
        in >> t;
        set << t;
        if (in.atEnd())
            break;
    }
    return in;
}

template <typename T>
QDataStream& operator<<(QDataStream &out, const QSet<T> &set)
{
    out << quint32(set.size());
    typename QSet<T>::const_iterator i = set.constBegin();
    while (i != set.constEnd()) {
        out << *i;
        ++i;
    }
    return out;
}

template <class Key, class T>
 QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash)
{
    QDataStream::Status oldStatus = in.status();
    in.resetStatus();
    hash.clear();

    quint32 n;
    in >> n;

    for (quint32 i = 0; i < n; ++i) {
        if (in.status() != QDataStream::Ok)
            break;

        Key k;
        T t;
        in >> k >> t;
        hash.insertMulti(k, t);
    }

    if (in.status() != QDataStream::Ok)
        hash.clear();
    if (oldStatus != QDataStream::Ok)
        in.setStatus(oldStatus);
    return in;
}

template <class Key, class T>
 QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
{
    out << quint32(hash.size());
    typename QHash<Key, T>::ConstIterator it = hash.end();
    typename QHash<Key, T>::ConstIterator begin = hash.begin();
    while (it != begin) {
        --it;
        out << it.key() << it.value();
    }
    return out;
}




template <class aKey, class aT>
 QDataStream &operator>>(QDataStream &in, QMap<aKey, aT> &map)

{
    QDataStream::Status oldStatus = in.status();
    in.resetStatus();
    map.clear();

    quint32 n;
    in >> n;

    map.detach();

    map.d->insertInOrder = true;

    for (quint32 i = 0; i < n; ++i) {
        if (in.status() != QDataStream::Ok)
            break;

        aKey key;
        aT value;
        in >> key >> value;
        map.insertMulti(key, value);
    }

    map.d->insertInOrder = false;

    if (in.status() != QDataStream::Ok)
        map.clear();
    if (oldStatus != QDataStream::Ok)
        in.setStatus(oldStatus);
    return in;
}

template <class Key, class T>
 QDataStream &operator<<(QDataStream &out, const QMap<Key, T> &map)
{
    out << quint32(map.size());
    typename QMap<Key, T>::ConstIterator it = map.end();
    typename QMap<Key, T>::ConstIterator begin = map.begin();
    while (it != begin) {
        --it;
        out << it.key() << it.value();
    }
    return out;
}





#line 2 "../../include/QtCore/qdatastream.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qpair.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

template <class T1, class T2>
struct QPair
{
    typedef T1 first_type;
    typedef T2 second_type;

    QPair() : first(T1()), second(T2()) {}
    QPair(const T1 &t1, const T2 &t2) : first(t1), second(t2) {}

    QPair<T1, T2> &operator=(const QPair<T1, T2> &other)
    { first = other.first; second = other.second; return *this; }

    T1 first;
    T2 second;
};

template <class T1, class T2>
inline bool operator==(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
{ return p1.first == p2.first && p1.second == p2.second; }

template <class T1, class T2>
inline bool operator!=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
{ return !(p1 == p2); }

template <class T1, class T2>
inline bool operator<(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
{
    return p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second);
}

template <class T1, class T2>
inline bool operator>(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
{
    return p2 < p1;
}

template <class T1, class T2>
inline bool operator<=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
{
    return !(p2 < p1);
}

template <class T1, class T2>
inline bool operator>=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
{
    return !(p1 < p2);
}

template <class T1, class T2>
 QPair<T1, T2> qMakePair(const T1 &x, const T2 &y)
{
    return QPair<T1, T2>(x, y);
}


template <class T1, class T2>
inline QDataStream& operator>>(QDataStream& s, QPair<T1, T2>& p)
{
    s >> p.first >> p.second;
    return s;
}

template <class T1, class T2>
inline QDataStream& operator<<(QDataStream& s, const QPair<T1, T2>& p)
{
    s << p.first << p.second;
    return s;
}




#line 2 "../../include/QtCore/qpair.h"
#line 30 "../../include/QtCore/../../src/corelib/io/qdebug.h"
#line 1 "../../include/QtCore/qtextstream.h"
#line 1 "../../include/QtCore/../../src/corelib/io/qtextstream.h"



















 




#line 1 "../../include/QtCore/qiodevice.h"
#line 26 "../../include/QtCore/../../src/corelib/io/qtextstream.h"
#line 1 "../../include/QtCore/qstring.h"
#line 27 "../../include/QtCore/../../src/corelib/io/qtextstream.h"
#line 1 "../../include/QtCore/qchar.h"
#line 28 "../../include/QtCore/../../src/corelib/io/qtextstream.h"

#line 1 "../../include/QtCore/qtextcodec.h"
#line 1 "../../include/QtCore/../../src/corelib/codecs/qtextcodec.h"



















 




#line 1 "../../include/QtCore/qstring.h"
#line 26 "../../include/QtCore/../../src/corelib/codecs/qtextcodec.h"
#line 1 "../../include/QtCore/qlist.h"
#line 27 "../../include/QtCore/../../src/corelib/codecs/qtextcodec.h"



typedef QtValidLicenseForCoreModule QtCoreModule;



class QTextCodec;
class QIODevice;

class QTextDecoder;
class QTextEncoder;

class  QTextCodec
{
    QTextCodec(const QTextCodec &); QTextCodec &operator=(const QTextCodec &);
public:
    static QTextCodec* codecForName(const QByteArray &name);
    static QTextCodec* codecForName(const char *name) { return codecForName(QByteArray(name)); }
    static QTextCodec* codecForMib(int mib);

    static QList<QByteArray> availableCodecs();
    static QList<int> availableMibs();

    static QTextCodec* codecForLocale();
    static void setCodecForLocale(QTextCodec *c);

    static QTextCodec* codecForTr();
    static void setCodecForTr(QTextCodec *c);

    static QTextCodec* codecForCStrings();
    static void setCodecForCStrings(QTextCodec *c);

    static QTextCodec *codecForHtml(const QByteArray &ba);

    QTextDecoder* makeDecoder() const;
    QTextEncoder* makeEncoder() const;

    bool canEncode(QChar) const;
    bool canEncode(const QString&) const;

    QString toUnicode(const QByteArray&) const;
    QString toUnicode(const char* chars) const;
    QByteArray fromUnicode(const QString& uc) const;
    enum ConversionFlag {
        DefaultConversion,
        ConvertInvalidToNull = 0x80000000,
        IgnoreHeader = 0x1
    };
    typedef QFlags<ConversionFlag> ConversionFlags;

    struct ConverterState {
        ConverterState(ConversionFlags f = DefaultConversion)
            : flags(f), remainingChars(0), invalidChars(0), d(0) { state_data[0] = state_data[1] = state_data[2] = 0; }
        ~ConverterState() { if (d) qFree(d); }
        ConversionFlags flags;
        int remainingChars;
        int invalidChars;
        uint state_data[3];
        void *d;
    private:
        ConverterState(const ConverterState &); ConverterState &operator=(const ConverterState &);
    };

    QString toUnicode(const char *in, int length, ConverterState *state = 0) const
        { return convertToUnicode(in, length, state); }
    QByteArray fromUnicode(const QChar *in, int length, ConverterState *state = 0) const
        { return convertFromUnicode(in, length, state); }

    virtual QByteArray name() const = 0;
    virtual QList<QByteArray> aliases() const;
    virtual int mibEnum() const = 0;

protected:
    virtual QString convertToUnicode(const char *in, int length, ConverterState *state) const = 0;
    virtual QByteArray convertFromUnicode(const QChar *in, int length, ConverterState *state) const = 0;

    QTextCodec();
    virtual ~QTextCodec();

public:

    static  QTextCodec* codecForContent(const char*, int) { return 0; }
    static  const char* locale();
    static  QTextCodec* codecForName(const char* hint, int) { return codecForName(QByteArray(hint)); }
     QByteArray fromUnicode(const QString& uc, int& lenInOut) const;
     QString toUnicode(const QByteArray&, int len) const;
     QByteArray mimeName() const { return name(); }
    static  QTextCodec *codecForIndex(int i) { return codecForName(availableCodecs().at(i)); }


private:
    friend class QTextCodecCleanup;
    static QTextCodec *cftr;
};
inline QFlags<QTextCodec::ConversionFlags::enum_type> operator|(QTextCodec::ConversionFlags::enum_type f1, QTextCodec::ConversionFlags::enum_type f2) { return QFlags<QTextCodec::ConversionFlags::enum_type>(f1) | f2; } inline QFlags<QTextCodec::ConversionFlags::enum_type> operator|(QTextCodec::ConversionFlags::enum_type f1, QFlags<QTextCodec::ConversionFlags::enum_type> f2) { return f2 | f1; }

inline QTextCodec* QTextCodec::codecForTr() { return cftr; }
inline void QTextCodec::setCodecForTr(QTextCodec *c) { cftr = c; }
inline QTextCodec* QTextCodec::codecForCStrings() { return QString::codecForCStrings; }
inline void QTextCodec::setCodecForCStrings(QTextCodec *c) { QString::codecForCStrings = c; }

class  QTextEncoder {
    QTextEncoder(const QTextEncoder &); QTextEncoder &operator=(const QTextEncoder &);
public:
    explicit QTextEncoder(const QTextCodec *codec) : c(codec), state() {}
    ~QTextEncoder();
    QByteArray fromUnicode(const QString& str);
    QByteArray fromUnicode(const QChar *uc, int len);

    QByteArray fromUnicode(const QString& uc, int& lenInOut);

private:
    const QTextCodec *c;
    QTextCodec::ConverterState state;
};

class  QTextDecoder {
    QTextDecoder(const QTextDecoder &); QTextDecoder &operator=(const QTextDecoder &);
public:
    explicit QTextDecoder(const QTextCodec *codec) : c(codec), state() {}
    ~QTextDecoder();
    QString toUnicode(const char* chars, int len);
    QString toUnicode(const QByteArray &ba);
private:
    const QTextCodec *c;
    QTextCodec::ConverterState state;
};





#line 2 "../../include/QtCore/qtextcodec.h"
#line 32 "../../include/QtCore/../../src/corelib/io/qtextstream.h"











typedef QtValidLicenseForCoreModule QtCoreModule;

class QTextCodec;
class QTextDecoder;

class QTextStreamPrivate;
class  QTextStream                                
{
    inline QTextStreamPrivate* d_func() { return reinterpret_cast<QTextStreamPrivate * >(d_ptr); } inline const QTextStreamPrivate* d_func() const { return reinterpret_cast<const QTextStreamPrivate * >(d_ptr); } friend class QTextStreamPrivate;

public:
    enum RealNumberNotation {
        SmartNotation,
        FixedNotation,
        ScientificNotation
    };
    enum FieldAlignment {
        AlignLeft,
        AlignRight,
        AlignCenter,
        AlignAccountingStyle
    };
    enum Status {
        Ok,
        ReadPastEnd,
        ReadCorruptData
    };
    enum NumberFlag {
        ShowBase = 0x1,
        ForcePoint = 0x2,
        ForceSign = 0x4,
        UppercaseBase = 0x8,
        UppercaseDigits = 0x10
    };
    typedef QFlags<NumberFlag> NumberFlags;

    QTextStream();
    explicit QTextStream(QIODevice *device);
    explicit QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
    explicit QTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
    explicit QTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
    explicit QTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly);
    virtual ~QTextStream();


    void setCodec(QTextCodec *codec);
    void setCodec(const char *codecName);
    QTextCodec *codec() const;
    void setAutoDetectUnicode(bool enabled);
    bool autoDetectUnicode() const;
    void setGenerateByteOrderMark(bool generate);
    bool generateByteOrderMark() const;


    void setDevice(QIODevice *device);
    QIODevice *device() const;

    void setString(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
    QString *string() const;

    Status status() const;
    void setStatus(Status status);
    void resetStatus();

    bool atEnd() const;
    void reset();
    void flush();
    bool seek(qint64 pos);

    void skipWhiteSpace();

    QString readLine(qint64 maxlen = 0);
    QString readAll();
    QString read(qint64 maxlen);

    void setFieldAlignment(FieldAlignment alignment);
    FieldAlignment fieldAlignment() const;

    void setPadChar(QChar ch);
    QChar padChar() const;

    void setFieldWidth(int width);
    int fieldWidth() const;

    void setNumberFlags(NumberFlags flags);
    NumberFlags numberFlags() const;

    void setIntegerBase(int base);
    int integerBase() const;

    void setRealNumberNotation(RealNumberNotation notation);
    RealNumberNotation realNumberNotation() const;

    void setRealNumberPrecision(int precision);
    int realNumberPrecision() const;

    QTextStream &operator>>(QChar &ch);
    QTextStream &operator>>(char &ch);
    QTextStream &operator>>(signed short &i);
    QTextStream &operator>>(unsigned short &i);
    QTextStream &operator>>(signed int &i);
    QTextStream &operator>>(unsigned int &i);
    QTextStream &operator>>(signed long &i);
    QTextStream &operator>>(unsigned long &i);
    QTextStream &operator>>(qlonglong &i);
    QTextStream &operator>>(qulonglong &i);
    QTextStream &operator>>(float &f);
    QTextStream &operator>>(double &f);
    QTextStream &operator>>(QString &s);
    QTextStream &operator>>(QByteArray &array);
    QTextStream &operator>>(char *c);

    QTextStream &operator<<(QBool b);
    QTextStream &operator<<(QChar ch);
    QTextStream &operator<<(char ch);
    QTextStream &operator<<(signed short i);
    QTextStream &operator<<(unsigned short i);
    QTextStream &operator<<(signed int i);
    QTextStream &operator<<(unsigned int i);
    QTextStream &operator<<(signed long i);
    QTextStream &operator<<(unsigned long i);
    QTextStream &operator<<(qlonglong i);
    QTextStream &operator<<(qulonglong i);
    QTextStream &operator<<(float f);
    QTextStream &operator<<(double f);
    QTextStream &operator<<(const QString &s);
    QTextStream &operator<<(const QByteArray &array);
    QTextStream &operator<<(const char *c);
    QTextStream &operator<<(const void *ptr);


    
    
    inline  int flags() const { return flagsInternal(); }
    inline  int flags(int f) { return flagsInternal(f); }

    inline  int setf(int bits)
    { int old = flagsInternal(); flagsInternal(flagsInternal() | bits); return old; }
    inline  int setf(int bits, int mask)
    { int old = flagsInternal(); flagsInternal(flagsInternal() | (bits & mask)); return old; }
    inline  int unsetf(int bits)
    { int old = flagsInternal(); flagsInternal(flagsInternal() & ~bits); return old; }

    inline  int width(int w)
    { int old = fieldWidth(); setFieldWidth(w); return old; }
    inline  int fill(int f)
    { QChar ch = padChar(); setPadChar(QChar(f)); return ch.unicode(); }
    inline  int precision(int p)
    { int old = realNumberPrecision(); setRealNumberPrecision(p); return old; }

    enum {
        skipws       = 0x0001,                        
        left         = 0x0002,                        
        right        = 0x0004,                        
        internal     = 0x0008,                        
        bin          = 0x0010,                        
        oct          = 0x0020,                        
        dec          = 0x0040,                        
        hex          = 0x0080,                        
        showbase     = 0x0100,                        
        showpoint    = 0x0200,                        
        uppercase    = 0x0400,                        
        showpos      = 0x0800,                        
        scientific   = 0x1000,                        
        fixed        = 0x2000                         
    };
    enum {
        basefield = bin | oct | dec | hex,
        adjustfield = left | right | internal,
        floatfield = scientific | fixed
    };


    enum Encoding { Locale, Latin1, Unicode, UnicodeNetworkOrder,
                    UnicodeReverse, RawUnicode, UnicodeUTF8 };
     void setEncoding(Encoding encoding);

    inline  QString read() { return readAll(); }
    inline  void unsetDevice() { setDevice(0); }


private:

    int flagsInternal() const;
    int flagsInternal(int flags);


    QTextStream(const QTextStream &); QTextStream &operator=(const QTextStream &);

    QTextStreamPrivate *d_ptr;
};

inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QTextStream::NumberFlags::enum_type f2) { return QFlags<QTextStream::NumberFlags::enum_type>(f1) | f2; } inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QFlags<QTextStream::NumberFlags::enum_type> f2) { return f2 | f1; }



 

typedef QTextStream & (*QTextStreamFunction)(QTextStream &);
typedef void (QTextStream::*QTSMFI)(int); 
typedef void (QTextStream::*QTSMFC)(QChar); 

class  QTextStreamManipulator
{
public:
    QTextStreamManipulator(QTSMFI m, int a) { mf = m; mc = 0; arg = a; }
    QTextStreamManipulator(QTSMFC m, QChar c) { mf = 0; mc = m; ch = c; }
    void exec(QTextStream &s) { if (mf) { (s.*mf)(arg); } else { (s.*mc)(ch); } }

private:
    QTSMFI mf;                                        
    QTSMFC mc;                                        
    int arg;                                          
    QChar ch;
};

inline QTextStream &operator>>(QTextStream &s, QTextStreamFunction f)
{ return (*f)(s); }

inline QTextStream &operator<<(QTextStream &s, QTextStreamFunction f)
{ return (*f)(s); }

inline QTextStream &operator<<(QTextStream &s, QTextStreamManipulator m)
{ m.exec(s); return s; }

 QTextStream &bin(QTextStream &s);
 QTextStream &oct(QTextStream &s);
 QTextStream &dec(QTextStream &s);
 QTextStream &hex(QTextStream &s);

 QTextStream &showbase(QTextStream &s);
 QTextStream &forcesign(QTextStream &s);
 QTextStream &forcepoint(QTextStream &s);
 QTextStream &noshowbase(QTextStream &s);
 QTextStream &noforcesign(QTextStream &s);
 QTextStream &noforcepoint(QTextStream &s);

 QTextStream &uppercasebase(QTextStream &s);
 QTextStream &uppercasedigits(QTextStream &s);
 QTextStream &lowercasebase(QTextStream &s);
 QTextStream &lowercasedigits(QTextStream &s);

 QTextStream &fixed(QTextStream &s);
 QTextStream &scientific(QTextStream &s);

 QTextStream &left(QTextStream &s);
 QTextStream &right(QTextStream &s);
 QTextStream &center(QTextStream &s);

 QTextStream &endl(QTextStream &s);
 QTextStream &flush(QTextStream &s);
 QTextStream &reset(QTextStream &s);

 QTextStream &bom(QTextStream &s);

 QTextStream &ws(QTextStream &s);

inline QTextStreamManipulator qSetFieldWidth(int width)
{
    QTSMFI func = &QTextStream::setFieldWidth;
    return QTextStreamManipulator(func,width);
}

inline QTextStreamManipulator qSetPadChar(QChar ch)
{
    QTSMFC func = &QTextStream::setPadChar;
    return QTextStreamManipulator(func, ch);
}

inline QTextStreamManipulator qSetRealNumberPrecision(int precision)
{
    QTSMFI func = &QTextStream::setRealNumberPrecision;
    return QTextStreamManipulator(func, precision);
}


typedef QTextStream QTS;

class  QTextIStream : public QTextStream
{
public:
    inline explicit QTextIStream(const QString *s) : QTextStream(const_cast<QString *>(s), QIODevice::ReadOnly) {}
    inline explicit QTextIStream(QByteArray *a) : QTextStream(a, QIODevice::ReadOnly) {}
    inline QTextIStream(FILE *f) : QTextStream(f, QIODevice::ReadOnly) {}

private:
    QTextIStream(const QTextIStream &); QTextIStream &operator=(const QTextIStream &);
};

class  QTextOStream : public QTextStream
{
public:
    inline explicit QTextOStream(QString *s) : QTextStream(s, QIODevice::WriteOnly) {}
    inline explicit QTextOStream(QByteArray *a) : QTextStream(a, QIODevice::WriteOnly) {}
    inline QTextOStream(FILE *f) : QTextStream(f, QIODevice::WriteOnly) {}

private:
    QTextOStream(const QTextOStream &); QTextOStream &operator=(const QTextOStream &);
};




#line 2 "../../include/QtCore/qtextstream.h"
#line 31 "../../include/QtCore/../../src/corelib/io/qdebug.h"
#line 1 "../../include/QtCore/qstring.h"
#line 32 "../../include/QtCore/../../src/corelib/io/qdebug.h"
#line 1 "../../include/QtCore/qvector.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qvector.h"



















 




#line 1 "../../include/QtCore/qiterator.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qvector.h"
#line 1 "../../include/QtCore/qatomic.h"
#line 27 "../../include/QtCore/../../src/corelib/tools/qvector.h"
#line 1 "../../include/QtCore/qalgorithms.h"
#line 28 "../../include/QtCore/../../src/corelib/tools/qvector.h"
#line 1 "../../include/QtCore/qlist.h"
#line 29 "../../include/QtCore/../../src/corelib/tools/qvector.h"

#line 1 "/usr/include/CC/vector"

#line 1 "/usr/include/CC/stdexcept"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/stdexcept /main/1"

#line 6 "/usr/include/CC/vector"


namespace std {

		
template<class _Ty, class _Alloc>
	class _Vector_val
	{	
protected:
	_Vector_val(_Alloc _Al = _Alloc())
		: _Alval(_Al)
		{}	

	typedef typename _Alloc::template
		rebind<_Ty>::other _Alty;

	_Alty _Alval;	
	};

		
template<class _Ty,
	class _Ax = allocator<_Ty> >
	class vector
		: public _Vector_val<_Ty, _Ax>
	{	
public:
	typedef vector<_Ty, _Ax> _Myt;
	typedef _Vector_val<_Ty, _Ax> _Mybase;
	typedef typename _Mybase::_Alty _Alloc;
	typedef _Alloc allocator_type;
	typedef typename _Alloc::size_type size_type;
	typedef typename _Alloc::difference_type difference_type;
	typedef typename _Alloc::pointer _Tptr;
	typedef typename _Alloc::const_pointer _Ctptr;
	typedef _Tptr pointer;
	typedef _Ctptr const_pointer;
	typedef typename _Alloc::reference reference;
	typedef typename _Alloc::const_reference const_reference;
	typedef typename _Alloc::value_type value_type;
	typedef _Ptrit<value_type, difference_type, _Tptr,
		reference, _Tptr, reference> iterator;
	typedef _Ptrit<value_type, difference_type, _Ctptr,
		const_reference, _Tptr, reference> const_iterator;
	typedef std::reverse_iterator<iterator>
		reverse_iterator;
	typedef std::reverse_iterator<const_iterator>
		const_reverse_iterator;

	vector()
		: _Mybase()
		{	
		_Buy(0); }

	explicit vector(const _Alloc& _Al)
		: _Mybase(_Al)
		{	
		_Buy(0); }

	explicit vector(size_type _Count)
		: _Mybase()
		{	
		if (_Buy(_Count))
			_Mylast = _Ufill(_Myfirst, _Count, _Ty()); }

	vector(size_type _Count, const _Ty& _Val)
		: _Mybase()
		{	
		if (_Buy(_Count))
			_Mylast = _Ufill(_Myfirst, _Count, _Val); }

	vector(size_type _Count, const _Ty& _Val, const _Alloc& _Al)
		: _Mybase(_Al)
		{	
		if (_Buy(_Count))
			_Mylast = _Ufill(_Myfirst, _Count, _Val); }

	vector(const _Myt& _Right)
		: _Mybase(_Right._Alval)
		{	
		if (_Buy(_Right.size()))
			_Mylast = _Ucopy(_Right.begin(), _Right.end(), _Myfirst); }

	template<class _Iter>
		vector(_Iter _First, _Iter _Last)
		: _Mybase()
		{	
		_Construct(_First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		vector(_Iter _First, _Iter _Last, const _Alloc& _Al)
		: _Mybase(_Al)
		{	
		_Construct(_First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		void _Construct(_Iter _Count, _Iter _Val, _Int_iterator_tag)
		{	
		size_type _Size = (size_type)_Count;
		if (_Buy(_Size))
			_Mylast = _Ufill(_Myfirst, _Size, (_Ty)_Val); }

	template<class _Iter>
		void _Construct(_Iter _First, _Iter _Last, input_iterator_tag)
		{	
		_Buy(0);
		insert(begin(), _First, _Last); }

	~vector()
		{	
		if (_Myfirst != 0)
			{	
			_Destroy(_Myfirst, _Mylast);
			_Mybase::_Alval.deallocate(_Myfirst, _Myend - _Myfirst); }
		_Myfirst = 0, _Mylast = 0, _Myend = 0; }

	_Myt& operator=(const _Myt& _Right)
		{	
		if (this == &_Right)
			;	
		else if (_Right.size() == 0)
			clear();	
		else if (_Right.size() <= size())
			{	
			pointer _Ptr = copy(_Right.begin(), _Right.end(), _Myfirst);
			_Destroy(_Ptr, _Mylast);
			_Mylast = _Myfirst + _Right.size(); }
		else if (_Right.size() <= capacity())
			{	
			const_iterator _Where = _Right.begin() + size();
			copy(_Right.begin(), _Where, _Myfirst);
			_Mylast = _Ucopy(_Where, _Right.end(), _Mylast); }
		else
			{	
			_Destroy(_Myfirst, _Mylast);
			_Mybase::_Alval.deallocate(_Myfirst, _Myend - _Myfirst);
			if (_Buy(_Right.size()))
				_Mylast = _Ucopy(_Right.begin(), _Right.end(), _Myfirst); }
		return (*this); }

	void reserve(size_type _Count)
		{	
		if (max_size() < _Count)
			_Xlen();	
		else if (capacity() < _Count)
			{	
			pointer _Ptr = _Mybase::_Alval.allocate(_Count, (void *)0);

			try {
			_Ucopy(begin(), end(), _Ptr);
			 } catch (...) {
			_Mybase::_Alval.deallocate(_Ptr, _Count);
			throw;
			}

			size_type _Size = size();
			if (_Myfirst != 0)
				{	
				_Destroy(_Myfirst, _Mylast);
				_Mybase::_Alval.deallocate(_Myfirst, _Myend - _Myfirst); }
			_Myend = _Ptr + _Count;
			_Mylast = _Ptr + _Size;
			_Myfirst = _Ptr; }}

	size_type capacity() const
		{	
		return (_Myfirst == 0 ? 0 : _Myend - _Myfirst); }

	iterator begin()
		{	
		return (iterator(_Myfirst)); }

	const_iterator begin() const
		{	
		return (const_iterator(_Myfirst)); }

	iterator end()
		{	
		return (iterator(_Mylast)); }

	const_iterator end() const
		{	
		return (const_iterator(_Mylast)); }

	reverse_iterator rbegin()
		{	
		return (reverse_iterator(end())); }

	const_reverse_iterator rbegin() const
		{	
		return (const_reverse_iterator(end())); }

	reverse_iterator rend()
		{	
		return (reverse_iterator(begin())); }

	const_reverse_iterator rend() const
		{	
		return (const_reverse_iterator(begin())); }

	void resize(size_type _Newsize)
		{	
		resize(_Newsize, _Ty()); }

	void resize(size_type _Newsize, _Ty _Val)
		{	
		if (size() < _Newsize)
			insert(end(), _Newsize - size(), _Val);
		else if (_Newsize < size())
			erase(begin() + _Newsize, end()); }

	size_type size() const
		{	
		return (_Myfirst == 0 ? 0 : _Mylast - _Myfirst); }

	size_type max_size() const
		{	
		return (_Mybase::_Alval.max_size()); }

	bool empty() const
		{	
		return (size() == 0); }

	_Alloc get_allocator() const
		{	
		return (_Mybase::_Alval); }

	const_reference at(size_type _Off) const
		{	
		if (size() <= _Off)
			_Xran();
		return (*(begin() + _Off)); }

	reference at(size_type _Off)
		{	
		if (size() <= _Off)
			_Xran();
		return (*(begin() + _Off)); }

	reference operator[](size_type _Off)
		{	
		return (*(begin() + _Off)); }

	const_reference operator[](size_type _Off) const
		{	
		return (*(begin() + _Off)); }

	reference front()
		{	
		return (*begin()); }

	const_reference front() const
		{	
		return (*begin()); }

	reference back()
		{	
		return (*(end() - 1)); }

	const_reference back() const
		{	
		return (*(end() - 1)); }

	void push_back(const _Ty& _Val)
		{	
		if (size() < capacity())
			_Mylast = _Ufill(_Mylast, 1, _Val);
		else
			insert(end(), _Val); }

	void pop_back()
		{	
		if (!empty())
			{	
			_Destroy(_Mylast - 1, _Mylast);
			--_Mylast; }}

	template<class _Iter>
		void assign(_Iter _First, _Iter _Last)
		{	
		_Assign(_First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		void _Assign(_Iter _Count, _Iter _Val, _Int_iterator_tag)
		{	
		assign((size_type)_Count, (_Ty)_Val); }

	template<class _Iter>
		void _Assign(_Iter _First, _Iter _Last, input_iterator_tag)
		{	
		erase(begin(), end());
		insert(begin(), _First, _Last); }

	void assign(size_type _Count, const _Ty& _Val)
		{	
		_Ty _Tmp = _Val;	
		erase(begin(), end());
		insert(begin(), _Count, _Tmp); }

	iterator insert(iterator _Where, const _Ty& _Val)
		{	
		size_type _Off = size() == 0 ? 0 : _Where - begin();
		insert(_Where, (size_type)1, _Val);
		return (begin() + _Off); }

	void insert(iterator _Where, size_type _Count, const _Ty& _Val)
		{	
		_Ty _Tmp = _Val;	
		size_type _Capacity = capacity();

		if (_Count == 0)
			;
		else if (max_size() - size() < _Count)
			_Xlen();	
		else if (_Capacity < size() + _Count)
			{	
			_Capacity = max_size() - _Capacity / 2 < _Capacity
				? 0 : _Capacity + _Capacity / 2;	
			if (_Capacity < size() + _Count)
				_Capacity = size() + _Count;
			pointer _Newvec = _Mybase::_Alval.allocate(_Capacity, (void *)0);
			pointer _Ptr = _Newvec;

			try {
			_Ptr = _Ucopy(begin(), _Where, _Newvec);	
			_Ptr = _Ufill(_Ptr, _Count, _Tmp);	
			_Ucopy(_Where, end(), _Ptr);	
			 } catch (...) {
			_Destroy(_Newvec, _Ptr);
			_Mybase::_Alval.deallocate(_Newvec, _Capacity);
			throw;
			}

			_Count += size();
			if (_Myfirst != 0)
				{	
				_Destroy(_Myfirst, _Mylast);
				_Mybase::_Alval.deallocate(_Myfirst, _Myend - _Myfirst); }
			_Myend = _Newvec + _Capacity;
			_Mylast = _Newvec + _Count;
			_Myfirst = _Newvec; }
		else if ((size_type)(end() - _Where) < _Count)
			{	
			_Ucopy(_Where, end(), _Where.base() + _Count);	

			try {
			_Ufill(_Mylast, _Count - (end() - _Where),
				_Tmp);	
			 } catch (...) {
			_Destroy(_Where.base() + _Count, _Mylast + _Count);
			throw;
			}

			_Mylast += _Count;
			fill(_Where, end() - _Count, _Tmp); }	
		else
			{	
			iterator _Oldend = end();
			_Mylast = _Ucopy(_Oldend - _Count, _Oldend,
				_Mylast);	
			copy_backward(_Where, _Oldend - _Count, _Oldend);	
			fill(_Where, _Where + _Count, _Tmp); }}	

	template<class _Iter>
		void insert(iterator _Where, _Iter _First, _Iter _Last)
		{	
		_Insert(_Where, _First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		void _Insert(iterator _Where, _Iter _First, _Iter _Last,
			_Int_iterator_tag)
		{	
		insert(_Where, (size_type)_First, (_Ty)_Last); }

	template<class _Iter>
		void _Insert(iterator _Where, _Iter _First, _Iter _Last,
			input_iterator_tag)
		{	
		for (; _First != _Last; ++_First, ++_Where)
			_Where = insert(_Where, *_First); }

	template<class _Iter>
		void _Insert(iterator _Where, _Iter _First, _Iter _Last,
			forward_iterator_tag)
		{	
		size_type _Count = 0;
		_Distance(_First, _Last, _Count);
		size_type _Capacity = capacity();

		if (_Count == 0)
			;
		else if (max_size() - size() < _Count)
			_Xlen();	
		else if (_Capacity < size() + _Count)
			{	
			_Capacity = max_size() - _Capacity / 2 < _Capacity
				? 0 : _Capacity + _Capacity / 2;	
			if (_Capacity < size() + _Count)
				_Capacity = size() + _Count;
			pointer _Newvec = _Mybase::_Alval.allocate(_Capacity, (void *)0);
			pointer _Ptr = _Newvec;

			try {
			_Ptr = _Ucopy(begin(), _Where, _Newvec);	
			_Ptr = _Ucopy(_First, _Last, _Ptr);	
			_Ucopy(_Where, end(), _Ptr);	
			 } catch (...) {
			_Destroy(_Newvec, _Ptr);
			_Mybase::_Alval.deallocate(_Newvec, _Capacity);
			throw;
			}

			_Count += size();
			if (_Myfirst != 0)
				{	
				_Destroy(_Myfirst, _Mylast);
				_Mybase::_Alval.deallocate(_Myfirst,
					_Myend - _Myfirst); }
			_Myend = _Newvec + _Capacity;
			_Mylast = _Newvec + _Count;
			_Myfirst = _Newvec; }
		else if ((size_type)(end() - _Where) < _Count)
			{	
			_Ucopy(_Where, end(), _Where.base() + _Count);	
			_Iter _Mid = _First;
			advance(_Mid, end() - _Where);

			try {
			_Ucopy(_Mid, _Last, _Mylast);	
			 } catch (...) {
			_Destroy(_Where.base() + _Count, _Mylast + _Count);
			throw;
			}

			_Mylast += _Count;
			copy(_First, _Mid, _Where); }	
		else
			{	
			iterator _Oldend = end();
			_Mylast = _Ucopy(_Oldend - _Count, _Oldend,
				_Mylast);	
			copy_backward(_Where, _Oldend - _Count, _Oldend);	
			copy(_First, _Last, _Where); }}	

	iterator erase(iterator _Where)
		{	
		copy(_Where + 1, end(), _Where);
		_Destroy(_Mylast - 1, _Mylast);
		--_Mylast;
		return (_Where); }

	iterator erase(iterator _First, iterator _Last)
		{	
		if (_First != _Last)
			{	
			pointer _Ptr = copy(_Last, end(), _First.base());
			_Destroy(_Ptr, _Mylast);
			_Mylast = _Ptr; }
		return (_First); }

	void clear()
		{	
		erase(begin(), end()); }

	bool _Eq(const _Myt& _Right) const
		{	
		return (size() == _Right.size()
			&& equal(begin(), end(), _Right.begin())); }

	bool _Lt(const _Myt& _Right) const
		{	
		return (lexicographical_compare(begin(), end(),
			_Right.begin(), _Right.end())); }

	void swap(_Myt& _Right)
		{	
		if (_Mybase::_Alval == _Right._Alval)
			{	
			std::swap(_Myfirst, _Right._Myfirst);
			std::swap(_Mylast, _Right._Mylast);
			std::swap(_Myend, _Right._Myend); }
		else
			{	
			_Myt _Ts = *this; *this = _Right, _Right = _Ts; }}

protected:
	bool _Buy(size_type _Capacity)
		{	
		_Myfirst = 0, _Mylast = 0, _Myend = 0;
		if (_Capacity == 0)
			return (false);
		else if (max_size() < _Capacity)
			_Xlen();	
		else
			{	
			_Myfirst = _Mybase::_Alval.allocate(_Capacity, (void *)0);
			_Mylast = _Myfirst;
			_Myend = _Myfirst + _Capacity; }
		return (true); }

	void _Destroy(pointer _First, pointer _Last)
		{	
		_Destroy_range(_First, _Last, _Alval); }

	template<class _Iter>
		pointer _Ucopy(_Iter _First, _Iter _Last, pointer _Ptr)
		{	
		return (uninitialized_copy(_First, _Last, _Ptr, _Alval)); }

	pointer _Ufill(pointer _Ptr, size_type _Count, const _Ty &_Val)
		{	
		uninitialized_fill_n(_Ptr, _Count, _Val, _Alval);
		return (_Ptr + _Count); }

	void _Xlen() const
		{	
		throw length_error("vector<T> too long"); }

	void _Xran() const
		{	
		throw out_of_range("invalid vector<T> subscript"); }

	pointer _Myfirst;	
	pointer _Mylast;	
	pointer _Myend;	
	};

		
template<class _Ty, class _Alloc> inline
	bool operator==(const vector<_Ty, _Alloc>& _Left,
		const vector<_Ty, _Alloc>& _Right)
	{	
	return (_Left._Eq(_Right)); }

template<class _Ty, class _Alloc> inline
	bool operator!=(const vector<_Ty, _Alloc>& _Left,
		const vector<_Ty, _Alloc>& _Right)
	{	
	return (!(_Left == _Right)); }

template<class _Ty, class _Alloc> inline
	bool operator<(const vector<_Ty, _Alloc>& _Left,
		const vector<_Ty, _Alloc>& _Right)
	{	
	return (_Left._Lt(_Right)); }

template<class _Ty, class _Alloc> inline
	bool operator>(const vector<_Ty, _Alloc>& _Left,
		const vector<_Ty, _Alloc>& _Right)
	{	
	return (_Right < _Left); }

template<class _Ty, class _Alloc> inline
	bool operator<=(const vector<_Ty, _Alloc>& _Left,
		const vector<_Ty, _Alloc>& _Right)
	{	
	return (!(_Right < _Left)); }

template<class _Ty, class _Alloc> inline
	bool operator>=(const vector<_Ty, _Alloc>& _Left,
		const vector<_Ty, _Alloc>& _Right)
	{	
	return (!(_Left < _Right)); }

template<class _Ty, class _Alloc> inline
	void swap(vector<_Ty, _Alloc>& _Left, vector<_Ty, _Alloc>& _Right)
	{	
	_Left.swap(_Right); }

		
typedef unsigned char _Vbase;	
const int _VBITS = 8 * sizeof (_Vbase);	

template<class _Alloc>
	class vector<_Bool, _Alloc>
	{	
public:
	typedef typename _Alloc::size_type size_type;
	typedef typename _Alloc::difference_type _Dift;
	typedef std::vector<_Vbase,
		typename _Alloc::template rebind<_Vbase>::other>
			_Vbtype;
	typedef std::vector<_Bool, _Alloc> _Myt;
	typedef _Dift difference_type;
	typedef _Bool _Ty;
	typedef _Alloc allocator_type;

		
	class reference
		{	
	public:
		reference()
			: _Mask(0), _Myptr(0)
			{}	

		reference(size_t _Off, _Vbase *_Ptr)
			: _Mask((_Vbase)(1 << _Off)), _Myptr(_Ptr)
			{}	

		reference& operator=(const reference& _Right)
			{	
			return (*this = bool(_Right)); }

		reference& operator=(bool _Val)
			{	
			if (_Val)
				*_Myptr |= _Mask;
			else
				*_Myptr &= ~_Mask;
			return (*this); }

		void flip()
			{	
			*_Myptr ^= _Mask; }

		bool operator~() const
			{	
			return (!bool(*this)); }

		operator bool() const
			{	
			return ((*_Myptr & _Mask) != 0); }

	protected:
		_Vbase _Mask;	
		_Vbase *_Myptr;	
		};

	typedef reference _Reft;
	typedef bool const_reference;
	typedef bool value_type;



		
	class const_iterator
		: public _Ranit<_Bool, _Dift, const_reference *, const_reference>
		{	
	public:
		typedef random_access_iterator_tag iterator_category;
		typedef _Bool value_type;
		typedef _Dift difference_type;
		typedef const_reference *pointer;
		typedef const_reference reference;

		const_iterator()
			: _Myoff(0), _Myptr(0)
			{}	

		const_iterator(size_t _Off,
			typename _Vbtype::const_iterator _Where)
			: _Myoff(_Off), _Myptr(_Where.base())
			{}	

		const_reference operator*() const
			{	
			return (_Reft(_Myoff, (_Vbase *)_Myptr)); }

		const_iterator& operator++()
			{	
			_Inc();
			return (*this); }

		const_iterator operator++(int)
			{	
			const_iterator _Tmp = *this;
			_Inc();
			return (_Tmp); }

		const_iterator& operator--()
			{	
			_Dec();
			return (*this); }

		const_iterator operator--(int)
			{	
			const_iterator _Tmp = *this;
			_Dec();
			return (_Tmp); }

		const_iterator& operator+=(difference_type _Off)
			{	
			_Myoff += _Off;
			_Myptr += _Myoff / _VBITS;
			_Myoff %= _VBITS;
			return (*this); }

		const_iterator operator+(difference_type _Off) const
			{	
			const_iterator _Tmp = *this;
			return (_Tmp += _Off); }

		const_iterator& operator-=(difference_type _Off)
			{	
			return (*this += -_Off); }

		const_iterator operator-(difference_type _Off) const
			{	
			const_iterator _Tmp = *this;
			return (_Tmp -= _Off); }

		difference_type operator-(const const_iterator _Right) const
			{	
			return (_VBITS * (_Myptr - _Right._Myptr)
				+ (difference_type)_Myoff
				- (difference_type)_Right._Myoff); }

		const_reference operator[](difference_type _Off) const
			{	
			return (*(*this + _Off)); }

		bool operator==(const const_iterator& _Right) const
			{	
			return (_Myptr == _Right._Myptr && _Myoff == _Right._Myoff); }

		bool operator!=(const const_iterator& _Right) const
			{	
			return (!(*this == _Right)); }

		bool operator<(const const_iterator& _Right) const
			{	
			return (_Myptr < _Right._Myptr
				|| _Myptr == _Right._Myptr && _Myoff < _Right._Myoff); }

		bool operator>(const const_iterator& _Right) const
			{	
			return (_Right < *this); }

		bool operator<=(const const_iterator& _Right) const
			{	
			return (!(_Right < *this)); }

		bool operator>=(const const_iterator& _Right) const
			{	
			return (!(*this < _Right)); }

		friend const_iterator operator+(difference_type _Off,
			const const_iterator& _Right)
			{	
			return (_Right + _Off); }

	protected:
		void _Dec()
			{	
			if (_Myoff != 0)
				--_Myoff;
			else
				_Myoff = _VBITS - 1, --_Myptr; }

		void _Inc()
			{	
			if (_Myoff < _VBITS - 1)
				++_Myoff;
			else
				_Myoff = 0, ++_Myptr; }

		size_t _Myoff;	
		const _Vbase *_Myptr;	
		};

		
	class iterator
		: public const_iterator
		{	
	public:
		typedef random_access_iterator_tag iterator_category;
		typedef _Bool value_type;
		typedef _Dift difference_type;
		typedef _Reft *pointer;
		typedef _Reft reference;

		iterator()
			: const_iterator()
			{}	

		iterator(size_t _Off, typename _Vbtype::iterator _Where)
			: const_iterator(_Off, _Where)
			{}	

		reference operator*() const
			{	
			return (_Reft(_Myoff, (_Vbase *)_Myptr)); }

		iterator& operator++()
			{	
			_Inc();
			return (*this); }

		iterator operator++(int)
			{	
			iterator _Tmp = *this;
			_Inc();
			return (_Tmp); }

		iterator& operator--()
			{	
			_Dec();
			return (*this); }

		iterator operator--(int)
			{	
			iterator _Tmp = *this;
			_Dec();
			return (_Tmp); }

		iterator& operator+=(difference_type _Off)
			{	
			_Myoff += _Off;
			_Myptr += _Myoff / _VBITS;
			_Myoff %= _VBITS;
			return (*this); }

		iterator operator+(difference_type _Off) const
			{	
			iterator _Tmp = *this;
			return (_Tmp += _Off); }

		iterator& operator-=(difference_type _Off)
			{	
			return (*this += -_Off); }

		iterator operator-(difference_type _Off) const
			{	
			iterator _Tmp = *this;
			return (_Tmp -= _Off); }

		difference_type operator-(const iterator _Right) const
			{	
			return (_VBITS * (_Myptr - _Right._Myptr)
				+ (difference_type)_Myoff
				- (difference_type)_Right._Myoff); }

		reference operator[](difference_type _Off) const
			{	
			return (*(*this + _Off)); }

		friend iterator operator+(difference_type _Off,
			const iterator& _Right)
			{	
			return (_Right + _Off); }
		};

	typedef iterator pointer;
	typedef const_iterator const_pointer;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	vector()
		: _Mysize(0), _Myvec()
		{}	

	explicit vector(const _Alloc& _Al)
		: _Mysize(0), _Myvec(_Al)
		{}	

	explicit vector(size_type _Count, bool _Val = false)
		: _Mysize(0), _Myvec(_Nw(_Count), (_Vbase)(_Val ? -1 : 0))
		{	
		_Trim(_Count); }

	vector(size_type _Count, bool _Val, const _Alloc& _Al)
		: _Mysize(0), _Myvec(_Nw(_Count), (_Vbase)(_Val ? -1 : 0), _Al)
		{	
		_Trim(_Count); }

	template<class _Iter>
		vector(_Iter _First, _Iter _Last)
		: _Mysize(0), _Myvec()
		{	
		_BConstruct(_First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		vector(_Iter _First, _Iter _Last, const _Alloc& _Al)
		: _Mysize(0), _Myvec(_Al)
		{	
		_BConstruct(_First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		void _BConstruct(_Iter _Count, _Iter _Val, _Int_iterator_tag)
		{	
		size_type _Num = (size_type)_Count;
		_Myvec.assign(_Num, (_Ty)_Val ? -1 : 0);
		_Trim(_Num); }

	template<class _Iter>
		void _BConstruct(_Iter _First, _Iter _Last, input_iterator_tag)
		{	
		insert(begin(), _First, _Last); }

	~vector()
		{	
		_Mysize = 0; }

	void reserve(size_type _Count)
		{	
		_Myvec.reserve(_Nw(_Count)); }

	size_type capacity() const
		{	
		return (_Myvec.capacity() * _VBITS); }

	iterator begin()
		{	
		return (iterator(0, _Myvec.begin())); }

	const_iterator begin() const
		{	
		return (const_iterator(0, _Myvec.begin())); }

	iterator end()
		{	
		iterator _Tmp = begin();
		if (0 < _Mysize)
			_Tmp += _Mysize;
		return (_Tmp); }

	const_iterator end() const
		{	
		const_iterator _Tmp = begin();
		if (0 < _Mysize)
			_Tmp += _Mysize;
		return (_Tmp); }

	reverse_iterator rbegin()
		{	
		return (reverse_iterator(end())); }

	const_reverse_iterator rbegin() const
		{	
		return (const_reverse_iterator(end())); }

	reverse_iterator rend()
		{	
		return (reverse_iterator(begin())); }

	const_reverse_iterator rend() const
		{	
		return (const_reverse_iterator(begin())); }

	void resize(size_type _Newsize, bool _Val = false)
		{	
		if (size() < _Newsize)
			insert(end(), _Newsize - size(), _Val);
		else if (_Newsize < size())
			erase(begin() + _Newsize, end()); }

	size_type size() const
		{	
		return (_Mysize); }

	size_type max_size() const
		{	
		static const size_type _Maxsize =
			_Myvec.max_size() < (size_type)(-1) / _VBITS
				? _Myvec.max_size() * _VBITS : (size_type)(-1);
		return (_Maxsize); }

	bool empty() const
		{	
		return (size() == 0); }

	_Alloc get_allocator() const
		{	
		return (_Myvec.get_allocator()); }

	const_reference at(size_type _Off) const
		{	
		if (size() <= _Off)
			_Xran();
		return (*(begin() + _Off)); }

	reference at(size_type _Off)
		{	
		if (size() <= _Off)
			_Xran();
		return (*(begin() + _Off)); }

	const_reference operator[](size_type _Off) const
		{	
		return (*(begin() + _Off)); }

	reference operator[](size_type _Off)
		{	
		return (*(begin() + _Off)); }

	reference front()
		{	
		return (*begin()); }

	const_reference front() const
		{	
		return (*begin()); }

	reference back()
		{	
		return (*(end() - 1)); }

	const_reference back() const
		{	
		return (*(end() - 1)); }

	void push_back(bool _Val)
		{	
		insert(end(), _Val); }

	void pop_back()
		{	
		if (!empty())
			erase(end() - 1); }

	template<class _Iter>
		void assign(_Iter _First, _Iter _Last)
		{	
		_Assign(_First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		void _Assign(_Iter _Count, _Iter _Val, _Int_iterator_tag)
		{	
		assign((size_type)_Count, (_Ty)_Val); }

	template<class _Iter>
		void _Assign(_Iter _First, _Iter _Last, input_iterator_tag)
		{	
		erase(begin(), end());
		insert(begin(), _First, _Last); }

	void assign(size_type _Count, bool _Val)
		{	
		erase(begin(), end());
		insert(begin(), _Count, _Val); }

	iterator insert(iterator _Where, bool _Val)
		{	
		size_type _Off = _Where - begin();
		insert(_Where, (size_type)1, _Val);
		return (begin() + _Off); }

	void insert(iterator _Where, size_type _Count, bool _Val)
		{	
		if (_Count == 0)
			;
		else if (max_size() - size() < _Count)
			_Xlen();	
		else
			{	
			if (size() == 0)
				{	
				_Myvec.resize(_Nw(size() + _Count), 0);
				_Where = begin(); }
			else
				{	
				size_type _Off = _Where - begin();
				_Myvec.resize(_Nw(size() + _Count), 0);
				_Where = begin() + _Off;
				copy_backward(_Where, end(), end() + _Count); }

			fill(_Where, _Where + _Count, _Val);	
			_Mysize += _Count; }}

	template<class _Iter>
		void insert(iterator _Where, _Iter _First, _Iter _Last)
		{	
		_Insert(_Where, _First, _Last, _Iter_cat(_First)); }

	template<class _Iter>
		void _Insert(iterator _Where, _Iter _Count, _Iter _Val,
			_Int_iterator_tag)
		{	
		insert(_Where, (size_type)_Count, (_Ty)_Val); }

	template<class _Iter>
		void _Insert(iterator _Where, _Iter _First, _Iter _Last,
			input_iterator_tag)
		{	
		size_type _Off = _Where - begin();

		for (; _First != _Last; ++_First, ++_Off)
			insert(begin() + _Off, *_First); }

	template<class _Iter>
		void _Insert(iterator _Where, _Iter _First, _Iter _Last,
			forward_iterator_tag)
		{	
		size_type _Capacity = 0;
		_Distance(_First, _Last, _Capacity);

		if (_Capacity == 0)
			;
		else if (max_size() - size() < _Capacity)
			_Xlen();	
		else
			{	
			if (size() == 0)
				{	
				_Myvec.resize(_Nw(size() + _Capacity), 0);
				_Where = begin(); }
			else
				{	
				size_type _Off = _Where - begin();
				_Myvec.resize(_Nw(size() + _Capacity), 0);
				_Where = begin() + _Off;
				copy_backward(_Where, end(), end() + _Capacity); }

			copy(_First, _Last, _Where);	
			_Mysize += _Capacity; }}

	iterator erase(iterator _Where)
		{	
		copy(_Where + 1, end(), _Where);
		_Trim(_Mysize - 1);
		return (_Where); }

	iterator erase(iterator _First, iterator _Last)
		{	
		iterator _Next = copy(_Last, end(), _First);
		_Trim(_Next - begin());
		return (_First); }

	void clear()
		{	
		erase(begin(), end()); }

	void flip()
		{	
		for (typename _Vbtype::iterator _Next = _Myvec.begin();
			_Next != _Myvec.end(); ++_Next)
			*_Next = (_Vbase)~*_Next;
		_Trim(_Mysize); }

	bool _Eq(const _Myt& _Right) const
		{	
		return (_Mysize == _Right._Mysize && _Myvec == _Right._Myvec); }

	bool _Lt(const _Myt& _Right) const
		{	
		return (lexicographical_compare(begin(), end(),
			_Right.begin(), _Right.end())); }

	void swap(_Myt& _Right)
		{	
		std::swap(_Mysize, _Right._Mysize);
		_Myvec.swap(_Right._Myvec); }

	static void swap(reference _Left, reference _Right)
		{	
		bool _Val = _Left;
		_Left = _Right;
		_Right = _Val; }

protected:
	static size_type _Nw(size_type _Count)
		{	
		return ((_Count + _VBITS - 1) / _VBITS); }

	void _Trim(size_type _Size)
		{	
		if (max_size() < _Size)
			_Xlen();	
		size_type _Words = _Nw(_Size);

		if (_Words < _Myvec.size())
			_Myvec.erase(_Myvec.begin() + _Words, _Myvec.end());
		_Mysize = _Size;
		_Size %= _VBITS;
		if (0 < _Size)
			_Myvec[_Words - 1] &= (_Vbase)((1 << _Size) - 1); }

	void _Xlen() const
		{	
		throw length_error("vector<bool> too long"); }

	void _Xran() const
		{	
		throw out_of_range("invalid vector<bool> subscript"); }

	size_type _Mysize;	
	_Vbtype _Myvec;	
	};

typedef vector<bool, allocator<bool> > _Bvector;

}	





 
















 
#line 33 "../../include/QtCore/../../src/corelib/tools/qvector.h"






typedef QtValidLicenseForCoreModule QtCoreModule;

struct  QVectorData
{
    QBasicAtomic ref;
    int alloc;
    int size;
    uint sharable : 1;

    static QVectorData shared_null;
    static QVectorData *malloc(int sizeofTypedData, int size, int sizeofT, QVectorData *init);
    static int grow(int sizeofTypedData, int size, int sizeofT, bool excessive);
};

template <typename T>
struct QVectorTypedData
{
    QBasicAtomic ref;
    int alloc;
    int size;
    uint sharable : 1;
    T array[1];
};

template <typename T>
class QVector
{
    typedef QVectorTypedData<T> Data;
    union { QVectorData *p; QVectorTypedData<T> *d; };

public:
    inline QVector() : p(&QVectorData::shared_null) { d->ref.ref(); }
    explicit QVector(int size);
    QVector(int size, const T &t);
    inline QVector(const QVector<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
    inline ~QVector() { if (!d) return; if (!d->ref.deref()) free(d); }
    QVector<T> &operator=(const QVector<T> &v);
    bool operator==(const QVector<T> &v) const;
    inline bool operator!=(const QVector<T> &v) const { return !(*this == v); }

    inline int size() const { return d->size; }

    inline bool isEmpty() const { return d->size == 0; }

    void resize(int size);

    inline int capacity() const { return d->alloc; }
    void reserve(int size);
    inline void squeeze() { realloc(d->size, d->size); }

    inline void detach() { if (d->ref != 1) detach_helper(); }
    inline bool isDetached() const { return d->ref == 1; }
    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }

    inline T *data() { detach(); return d->array; }
    inline const T *data() const { return d->array; }
    inline const T *constData() const { return d->array; }
    void clear();

    const T &at(int i) const;
    T &operator[](int i);
    const T &operator[](int i) const;
    void append(const T &t);
    void prepend(const T &t);
    void insert(int i, const T &t);
    void insert(int i, int n, const T &t);
    void replace(int i, const T &t);
    void remove(int i);
    void remove(int i, int n);

    QVector<T> &fill(const T &t, int size = -1);

    int indexOf(const T &t, int from = 0) const;
    int lastIndexOf(const T &t, int from = -1) const;
    bool contains(const T &t) const;
    int count(const T &t) const;

    
    typedef T* iterator;
    typedef const T* const_iterator;
    inline iterator begin() { detach(); return d->array; }
    inline const_iterator begin() const { return d->array; }
    inline const_iterator constBegin() const { return d->array; }
    inline iterator end() { detach(); return d->array + d->size; }
    inline const_iterator end() const { return d->array + d->size; }
    inline const_iterator constEnd() const { return d->array + d->size; }
    iterator insert(iterator before, int n, const T &x);
    inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); }
    iterator erase(iterator begin, iterator end);
    inline iterator erase(iterator pos) { return erase(pos, pos+1); }

    
    inline int count() const { return d->size; }
    inline T& first() { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qvector.h",132);} while (0); return *begin(); }
    inline const T &first() const { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qvector.h",133);} while (0); return *begin(); }
    inline T& last() { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qvector.h",134);} while (0); return *(end()-1); }
    inline const T &last() const { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qvector.h",135);} while (0); return *(end()-1); }
    QVector<T> mid(int pos, int length = -1) const;

    T value(int i) const;
    T value(int i, const T &defaultValue) const;

    
    typedef T value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;

    typedef ptrdiff_t difference_type;



    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    typedef int size_type;
    inline void push_back(const T &t) { append(t); }
    inline void push_front(const T &t) { prepend(t); }
    void pop_back() { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qvector.h",157);} while (0); erase(end()-1); }
    void pop_front() { do {if(!(!isEmpty()))qt_assert("!isEmpty()","../../include/QtCore/../../src/corelib/tools/qvector.h",158);} while (0); erase(begin()); }
    inline bool empty() const
    { return d->size == 0; }
    inline T& front() { return first(); }
    inline const_reference front() const { return first(); }
    inline reference back() { return last(); }
    inline const_reference back() const { return last(); }

    
    QVector<T> &operator+=(const QVector<T> &l);
    inline QVector<T> operator+(const QVector<T> &l) const
    { QVector n = *this; n += l; return n; }
    inline QVector<T> &operator+=(const T &t)
    { append(t); return *this; }
    inline QVector<T> &operator<< (const T &t)
    { append(t); return *this; }
    inline QVector<T> &operator<<(const QVector<T> &l)
    { *this += l; return *this; }

    QList<T> toList() const;

    static QVector<T> fromList(const QList<T> &list);


    static inline QVector<T> fromStdVector(const std::vector<T> &vector)
    { QVector<T> tmp; qCopy(vector.begin(), vector.end(), std::back_inserter(tmp)); return tmp; }
    inline std::vector<T> toStdVector() const
    { std::vector<T> tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }


private:
    void detach_helper();
    QVectorData *malloc(int alloc);
    void realloc(int size, int alloc);
    void free(Data *d);
};

template <typename T>
void QVector<T>::detach_helper()
{ realloc(d->size, d->alloc); }
template <typename T>
void QVector<T>::reserve(int asize)
{ if (asize > d->alloc) realloc(d->size, asize); }
template <typename T>
void QVector<T>::resize(int asize)
{ realloc(asize, (asize > d->alloc || (asize < d->size && asize < (d->alloc >> 1))) ?
          QVectorData::grow(sizeof(Data), asize, sizeof(T), QTypeInfo<T>::isStatic)
          : d->alloc); }
template <typename T>
inline void QVector<T>::clear()
{ *this = QVector<T>(); }
template <typename T>
inline const T &QVector<T>::at(int i) const
{ do {if(!(i >= 0 && i < d->size))qt_assert_x("QVector<T>::at", "index out of range","../../include/QtCore/../../src/corelib/tools/qvector.h",211);} while (0);
  return d->array[i]; }
template <typename T>
inline const T &QVector<T>::operator[](int i) const
{ do {if(!(i >= 0 && i < d->size))qt_assert_x("QVector<T>::operator[]", "index out of range","../../include/QtCore/../../src/corelib/tools/qvector.h",215);} while (0);
  return d->array[i]; }
template <typename T>
inline T &QVector<T>::operator[](int i)
{ do {if(!(i >= 0 && i < d->size))qt_assert_x("QVector<T>::operator[]", "index out of range","../../include/QtCore/../../src/corelib/tools/qvector.h",219);} while (0);
  return data()[i]; }
template <typename T>
inline void QVector<T>::insert(int i, const T &t)
{ do {if(!(i >= 0 && i <= d->size))qt_assert_x("QVector<T>::insert", "index out of range","../../include/QtCore/../../src/corelib/tools/qvector.h",223);} while (0);
  insert(begin() + i, 1, t); }
template <typename T>
inline void QVector<T>::insert(int i, int n, const T &t)
{ do {if(!(i >= 0 && i <= d->size))qt_assert_x("QVector<T>::insert", "index out of range","../../include/QtCore/../../src/corelib/tools/qvector.h",227);} while (0);
  insert(begin() + i, n, t); }
template <typename T>
inline void QVector<T>::remove(int i, int n)
{ do {if(!(i >= 0 && n >= 0 && i + n <= d->size))qt_assert_x("QVector<T>::remove", "index out of range","../../include/QtCore/../../src/corelib/tools/qvector.h",231);} while (0);
  erase(begin() + i, begin() + i + n); }
template <typename T>
inline void QVector<T>::remove(int i)
{ do {if(!(i >= 0 && i < d->size))qt_assert_x("QVector<T>::remove", "index out of range","../../include/QtCore/../../src/corelib/tools/qvector.h",235);} while (0);
  erase(begin() + i, begin() + i + 1); }
template <typename T>
inline void QVector<T>::prepend(const T &t)
{ insert(begin(), 1, t); }

template <typename T>
inline void QVector<T>::replace(int i, const T &t)
{
    do {if(!(i >= 0 && i < d->size))qt_assert_x("QVector<T>::replace", "index out of range","../../include/QtCore/../../src/corelib/tools/qvector.h",244);} while (0);
    const T copy(t);
    data()[i] = copy;
}

template <typename T>
QVector<T> &QVector<T>::operator=(const QVector<T> &v)
{
    typename QVector::Data *x = v.d;
    x->ref.ref();
    x = qAtomicSetPtr(&d, x);
    if (!x->ref.deref())
        free(x);
    if (!d->sharable)
        detach_helper();
    return *this;
}

template <typename T>
inline QVectorData *QVector<T>::malloc(int aalloc)
{
    return static_cast<QVectorData *>(qMalloc(sizeof(Data) + (aalloc - 1) * sizeof(T)));
}

template <typename T>
QVector<T>::QVector(int asize)
{
    p = malloc(asize);
    d->ref.init(1);
    d->alloc = d->size = asize;
    d->sharable = true;
    if (QTypeInfo<T>::isComplex) {
        T* b = d->array;
        T* i = d->array + d->size;
        while (i != b)
            new (--i) T;
    } else {
        qMemSet(d->array, 0, asize * sizeof(T));
    }
}

template <typename T>
QVector<T>::QVector(int asize, const T &t)
{
    p = malloc(asize);
    d->ref.init(1);
    d->alloc = d->size = asize;
    d->sharable = true;
    T* i = d->array + d->size;
    while (i != d->array)
        new (--i) T(t);
}

template <typename T>
void QVector<T>::free(Data *x)
{
    if (QTypeInfo<T>::isComplex) {
        T* b = x->array;
        T* i = b + x->size;
        while (i-- != b)
             i->~T();
    }
    qFree(x);
}

template <typename T>
void QVector<T>::realloc(int asize, int aalloc)
{
    T *j, *i, *b;
    union { QVectorData *p; Data *d; } x;
    x.d = d;

    if (QTypeInfo<T>::isComplex && aalloc == d->alloc && d->ref == 1) {
        
        i = d->array + d->size;
        j = d->array + asize;
        if (i > j) {
            while (i-- != j)
                i->~T();
        } else {
            while (j-- != i)
                new (j) T;
        }
        d->size = asize;
        return;
    }

    if (aalloc != d->alloc || d->ref != 1) {
        
        if (QTypeInfo<T>::isStatic) {
            x.p = malloc(aalloc);
        } else if (d->ref != 1) {
            x.p = QVectorData::malloc(sizeof(Data), aalloc, sizeof(T), p);
        } else {
            if (QTypeInfo<T>::isComplex) {
                
                
                if (asize < d->size) {
                    j = d->array + asize;
                    i = d->array + d->size;
                    while (i-- != j)
                        i->~T();
                    i = d->array + asize;
                }
            }
            x.p = p =
                  static_cast<QVectorData *>(qRealloc(p, sizeof(Data) + (aalloc - 1) * sizeof(T)));
        }
        x.d->ref.init(1);
        x.d->sharable = true;
    }
    if (QTypeInfo<T>::isComplex) {
        if (asize < d->size) {
            j = d->array + asize;
            i = x.d->array + asize;
        } else {
            
            i = x.d->array + asize;
            j = x.d->array + d->size;
            while (i != j)
                new (--i) T;
            j = d->array + d->size;
        }
        if (i != j) {
            
            b = x.d->array;
            while (i != b)
                new (--i) T(*--j);
        }
    } else if (asize > d->size) {
        
        qMemSet(x.d->array + d->size, 0, (asize - d->size) * sizeof(T));
    }
    x.d->size = asize;
    x.d->alloc = aalloc;
    if (d != x.d) {
        x.d = qAtomicSetPtr(&d, x.d);
        if (!x.d->ref.deref())
            free(x.d);
    }
}

template<typename T>
 T QVector<T>::value(int i) const
{
    if (i < 0 || i >= p->size) {
        return T();
    }
    return d->array[i];
}
template<typename T>
 T QVector<T>::value(int i, const T &defaultValue) const
{
    return ((i < 0 || i >= p->size) ? defaultValue : d->array[i]);
}

template <typename T>
void QVector<T>::append(const T &t)
{
    const T copy(t);
    if (d->ref != 1 || d->size + 1 > d->alloc)
        realloc(d->size, QVectorData::grow(sizeof(Data), d->size + 1, sizeof(T),
                                           QTypeInfo<T>::isStatic));
    if (QTypeInfo<T>::isComplex)
        new (d->array + d->size) T(copy);
    else
        d->array[d->size] = copy;
    ++d->size;
}


template <typename T>
typename QVector<T>::iterator QVector<T>::insert(iterator before, size_type n, const T &t)
{
    int offset = before - d->array;
    if (n != 0) {
        const T copy(t);
        if (d->ref != 1 || d->size + n > d->alloc)
            realloc(d->size, QVectorData::grow(sizeof(Data), d->size + n, sizeof(T),
                                               QTypeInfo<T>::isStatic));
        if (QTypeInfo<T>::isStatic) {
            T *b = d->array + d->size;
            T *i = d->array + d->size + n;
            while (i != b)
                new (--i) T;
            i = d->array + d->size;
            T *j = i + n;
            b = d->array + offset;
            while (i != b)
                *--j = *--i;
            i = b+n;
            while (i != b)
                *--i = copy;
        } else {
            T *b = d->array + offset;
            T *i = b + n;
            memmove(i, b, (d->size - offset) * sizeof(T));
            while (i != b)
                new (--i) T(copy);
        }
        d->size += n;
    }
    return d->array + offset;
}

template <typename T>
typename QVector<T>::iterator QVector<T>::erase(iterator abegin, iterator aend)
{
    int f = abegin - d->array;
    int l = aend - d->array;
    int n = l - f;
    detach();
    if (QTypeInfo<T>::isComplex) {
        qCopy(d->array+l, d->array+d->size, d->array+f);
        T *i = d->array+d->size;
        T* b = d->array+d->size-n;
        while (i != b) {
            --i;
            i->~T();
        }
    } else {
        memmove(d->array + f, d->array + l, (d->size-l)*sizeof(T));
    }
    d->size -= n;
    return d->array + f;
}

template <typename T>
bool QVector<T>::operator==(const QVector<T> &v) const
{
    if (d->size != v.d->size)
        return false;
    if (d == v.d)
        return true;
    T* b = d->array;
    T* i = b + d->size;
    T* j = v.d->array + d->size;
    while (i != b)
        if (!(*--i == *--j))
            return false;
    return true;
}

template <typename T>
QVector<T> &QVector<T>::fill(const T &from, int asize)
{
    const T copy(from);
    resize(asize < 0 ? d->size : asize);
    if (d->size) {
        T *i = d->array + d->size;
        T *b = d->array;
        while (i != b)
            *--i = copy;
    }
    return *this;
}

template <typename T>
QVector<T> &QVector<T>::operator+=(const QVector &l)
{
    int newSize = d->size + l.d->size;
    realloc(d->size, newSize);

    T *w = d->array + newSize;
    T *i = l.d->array + l.d->size;
    T *b = l.d->array;
    while (i != b) {
        if (QTypeInfo<T>::isComplex)
            new (--w) T(*--i);
        else
            *--w = *--i;
    }
    d->size = newSize;
    return *this;
}

template <typename T>
int QVector<T>::indexOf(const T &t, int from) const
{
    if (from < 0)
        from = qMax(from + d->size, 0);
    if (from < d->size) {
        T* n = d->array + from - 1;
        T* e = d->array + d->size;
        while (++n != e)
            if (*n == t)
                return n - d->array;
    }
    return -1;
}

template <typename T>
int QVector<T>::lastIndexOf(const T &t, int from) const
{
    if (from < 0)
        from += d->size;
    else if (from >= d->size)
        from = d->size-1;
    if (from >= 0) {
        T* b = d->array;
        T* n = d->array + from + 1;
        while (n != b) {
            if (*--n == t)
                return n - b;
        }
    }
    return -1;
}

template <typename T>
bool QVector<T>::contains(const T &t) const
{
    T* b = d->array;
    T* i = d->array + d->size;
    while (i != b)
        if (*--i == t)
            return true;
    return false;
}

template <typename T>
int QVector<T>::count(const T &t) const
{
    int c = 0;
    T* b = d->array;
    T* i = d->array + d->size;
    while (i != b)
        if (*--i == t)
            ++c;
    return c;
}

template <typename T>
 QVector<T> QVector<T>::mid(int pos, int length) const
{
    if (length < 0)
        length = size() - pos;
    if (pos == 0 && length == size())
        return *this;
    QVector<T> copy;
    if (pos + length > size())
        length = size() - pos;
    for (int i = pos; i < pos + length; ++i)
        copy += at(i);
    return copy;
}

template <typename T>
 QList<T> QVector<T>::toList() const
{
    QList<T> result;
    for (int i = 0; i < size(); ++i)
        result.append(at(i));
    return result;
}

template <typename T>
 QVector<T> QList<T>::toVector() const
{
    QVector<T> result(size());
    for (int i = 0; i < size(); ++i)
        result[i] = at(i);
    return result;
}

template <typename T>
QVector<T> QVector<T>::fromList(const QList<T> &list)
{
    return list.toVector();
}

template <typename T>
QList<T> QList<T>::fromVector(const QVector<T> &vector)
{
    return vector.toList();
}

template <class T> class QVectorIterator { typedef typename QVector<T> ::const_iterator const_iterator; QVector<T> c; const_iterator i; public: inline QVectorIterator(const QVector<T> &container) : c(container), i(c . constBegin()) {} inline QVectorIterator &operator=(const QVector<T> &container) { c = container; i = c . constBegin(); return *this; } inline void toFront() { i = c . constBegin(); } inline void toBack() { i = c . constEnd(); } inline bool hasNext() const { return i != c . constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c . constBegin(); } inline const T &previous() { return * --i; } inline const T &peekPrevious() const { const_iterator p = i; return * --p; } inline bool findNext(const T &t) { while (i != c . constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c . constBegin()) if (*(--i) == t) return true; return false; } };
template <class T> class QMutableVectorIterator { typedef typename QVector<T> ::iterator iterator; QVector<T> *c; iterator i, n; inline bool item_exists() const { return n != c->constEnd(); } public: inline QMutableVectorIterator(QVector<T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableVectorIterator() { c->setSharable(true); } inline QMutableVectorIterator &operator=(QVector<T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != i; } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != i; } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return * --p; } inline void remove() { if (c->constEnd() != n) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != n) *n = t; } inline T &value() { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qvector.h",622);} while (0); return *n; } inline const T &value() const { do {if(!(item_exists()))qt_assert("item_exists()","../../include/QtCore/../../src/corelib/tools/qvector.h",622);} while (0); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != (n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != i) if (*(n = --i) == t) return true; n = c->end(); return false; } };



#line 2 "../../include/QtCore/qvector.h"
#line 33 "../../include/QtCore/../../src/corelib/io/qdebug.h"



typedef QtValidLicenseForCoreModule QtCoreModule;


class  QDebug
{
    struct Stream {
        Stream(QtMsgType t) : ts(&buffer, QIODevice::WriteOnly), ref(1), type(t), space(true){}
        QTextStream ts;
        QString buffer;
        int ref;
        QtMsgType type;
        bool space;
    } *stream;
public:
    inline QDebug(QtMsgType t) : stream(new Stream(t)) {}
    inline QDebug(const QDebug &o):stream(o.stream) { ++stream->ref; }
    inline QDebug &operator=(const QDebug &other);
    inline ~QDebug()
        { if (!--stream->ref) { qt_message_output(stream->type, stream->buffer.toLocal8Bit().data()); delete stream; } }
    inline QDebug &space() { stream->space = true; stream->ts << " "; return *this; }
    inline QDebug &nospace() { stream->space = false; return *this; }
    inline QDebug &maybeSpace() { if (stream->space) stream->ts << " "; return *this; }

    inline QDebug &operator<<(QChar t) { stream->ts << "\'" << t << "\'"; return maybeSpace(); }
    inline QDebug &operator<<(bool t) { stream->ts << (t ? "true" : "false"); return maybeSpace(); }
    inline QDebug &operator<<(char t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(signed short t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(unsigned short t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(signed int t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(unsigned int t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(signed long t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(unsigned long t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(qint64 t)
        { stream->ts << QString::number(t); return maybeSpace(); }
    inline QDebug &operator<<(quint64 t)
        { stream->ts << QString::number(t); return maybeSpace(); }
    inline QDebug &operator<<(float t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(double t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(const char* t) { stream->ts  << t; return maybeSpace(); }
    inline QDebug &operator<<(const QString & t) { stream->ts << "\"" << t  << "\""; return maybeSpace(); }
    inline QDebug &operator<<(const QLatin1String &t) { stream->ts << "\""  << t.latin1() << "\""; return maybeSpace(); }
    inline QDebug &operator<<(const QByteArray & t) { stream->ts  << "\"" << t << "\""; return maybeSpace(); }
    inline QDebug &operator<<(const void * t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(QTextStreamFunction f) {
        stream->ts << f;
        return *this;
    }

    inline QDebug &operator<<(QTextStreamManipulator m)
    { stream->ts << m; return *this; }
};

inline QDebug &QDebug::operator=(const QDebug &other)
{
    if (this != &other) {
        QDebug copy(other);
        qSwap(stream, copy.stream);
    }
    return *this;
}

template <class T>
inline QDebug operator<<(QDebug debug, const QList<T> &list)
{
    debug.nospace() << "(";
    for (typename QList<T>::size_type i = 0; i < list.count(); ++i) {
        if (i)
            debug << ", ";
        debug << list.at(i);
    }
    debug << ")";
    return debug.space();
}

template <typename T>
inline QDebug operator<<(QDebug debug, const QVector<T> &vec)
{
    return operator<<(debug, vec.toList());
}

template <class aKey, class aT>
inline QDebug operator<<(QDebug debug, const QMap<aKey, aT> &map)
{
    debug.nospace() << "QMap(";
    for (typename QMap<aKey, aT>::const_iterator it = map.constBegin();
         it != map.constEnd(); ++it) {
        debug << "(" << it.key() << ", " << it.value() << ")";
    }
    debug << ")";
    return debug.space();
}

template <class aKey, class aT>
inline QDebug operator<<(QDebug debug, const QHash<aKey, aT> &hash)
{
    debug.nospace() << "QHash(";
    for (typename QHash<aKey, aT>::const_iterator it = hash.constBegin();
            it != hash.constEnd(); ++it)
        debug << "(" << it.key() << ", " << it.value() << ")";
    debug << ")";
    return debug.space();
}

template <class T1, class T2>
inline QDebug operator<<(QDebug debug, const QPair<T1, T2> &pair)
{
    debug.nospace() << "QPair(" << pair.first << "," << pair.second << ")";
    return debug.space();
}

inline  QDebug qDebug() { return QDebug(QtDebugMsg); }
inline  QDebug qWarning() { return QDebug(QtWarningMsg); }
inline  QDebug qCritical() { return QDebug(QtCriticalMsg); }

#line 181 "../../include/QtCore/../../src/corelib/io/qdebug.h"



#line 2 "../../include/QtCore/qdebug.h"
#line 23 "text/qtextengine.cpp"
#line 1 "text/qtextformat.h"



















 




#line 1 "../../include/QtGui/qcolor.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qcolor.h"



















 




#line 1 "../../include/QtGui/qrgb.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qrgb.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qrgb.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

typedef unsigned int QRgb;                        

const QRgb  RGB_MASK    = 0x00ffffff;                

 inline int qRed(QRgb rgb)                
{ return ((rgb >> 16) & 0xff); }

 inline int qGreen(QRgb rgb)                
{ return ((rgb >> 8) & 0xff); }

 inline int qBlue(QRgb rgb)                
{ return (rgb & 0xff); }

 inline int qAlpha(QRgb rgb)                
{ return ((rgb >> 24) & 0xff); }

 inline QRgb qRgb(int r, int g, int b)
{ return (0xff << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); }

 inline QRgb qRgba(int r, int g, int b, int a)
{ return ((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); }

 inline int qGray(int r, int g, int b)
{ return (r*11+g*16+b*5)/32; }

 inline int qGray(QRgb rgb)                
{ return qGray(qRed(rgb), qGreen(rgb), qBlue(rgb)); }

 inline bool qIsGray(QRgb rgb)
{ return qRed(rgb) == qGreen(rgb) && qRed(rgb) == qBlue(rgb); }



#line 2 "../../include/QtGui/qrgb.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qcolor.h"
#line 1 "../../include/QtCore/qnamespace.h"
#line 27 "../../include/QtGui/../../src/gui/painting/qcolor.h"
#line 1 "../../include/QtCore/qstringlist.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qstringlist.h"



















 




#line 1 "../../include/QtCore/qalgorithms.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qstringlist.h"
#line 1 "../../include/QtCore/qdatastream.h"
#line 27 "../../include/QtCore/../../src/corelib/tools/qstringlist.h"
#line 1 "../../include/QtCore/qlist.h"
#line 28 "../../include/QtCore/../../src/corelib/tools/qstringlist.h"
#line 1 "../../include/QtCore/qregexp.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qregexp.h"



















 






#line 1 "../../include/QtCore/qstring.h"
#line 28 "../../include/QtCore/../../src/corelib/tools/qregexp.h"
#line 1 "/usr/include/CC/new"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/new /main/1"

 


 

#line 30 "../../include/QtCore/../../src/corelib/tools/qregexp.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

struct QRegExpPrivate;
class QStringList;

class  QRegExp
{
public:
    enum PatternSyntax { RegExp, Wildcard, FixedString };
    enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch };

    QRegExp();
    explicit QRegExp(const QString &pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive,
		     PatternSyntax syntax = RegExp);
    QRegExp(const QRegExp &rx);
    ~QRegExp();
    QRegExp &operator=(const QRegExp &rx);

    bool operator==(const QRegExp &rx) const;
    inline bool operator!=(const QRegExp &rx) const { return !operator==(rx); }

    bool isEmpty() const;
    bool isValid() const;
    QString pattern() const;
    void setPattern(const QString &pattern);
    Qt::CaseSensitivity caseSensitivity() const;
    void setCaseSensitivity(Qt::CaseSensitivity cs);

    inline  bool caseSensitive() const { return caseSensitivity() == Qt::CaseSensitive; }
    inline  void setCaseSensitive(bool sensitive)
    { setCaseSensitivity(sensitive ? Qt::CaseSensitive : Qt::CaseInsensitive); }


    PatternSyntax patternSyntax() const;
    void setPatternSyntax(PatternSyntax syntax);

    inline  bool wildcard() const { return patternSyntax() == Wildcard; }
    inline  void setWildcard(bool wildcard)
    { setPatternSyntax(wildcard ? Wildcard : RegExp); }



    bool isMinimal() const;
    void setMinimal(bool minimal);

    inline  bool minimal() const { return isMinimal(); }


    bool exactMatch(const QString &str) const;

    int indexIn(const QString &str, int offset = 0, CaretMode caretMode = CaretAtZero) const;
    int lastIndexIn(const QString &str, int offset = -1, CaretMode caretMode = CaretAtZero) const;

    inline  int search(const QString &str, int from = 0,
                                CaretMode caretMode = CaretAtZero) const
    { return indexIn(str, from, caretMode); }
    inline  int searchRev(const QString &str, int from = -1,
                                   CaretMode caretMode = CaretAtZero) const
    { return lastIndexIn(str, from, caretMode); }

    int matchedLength() const;

    int numCaptures() const;
    QStringList capturedTexts();
    QString cap(int nth = 0);
    int pos(int nth = 0);
    QString errorString();


    static QString escape(const QString &str);


    inline explicit QRegExp(const QString &pattern, bool cs, bool wildcard = false)
    {
        new (this)
            QRegExp(pattern, cs ? Qt::CaseSensitive : Qt::CaseInsensitive,
                    wildcard ? Wildcard : RegExp);
    }


private:
    QRegExpPrivate *priv;
};

template <> class QTypeInfo<QRegExp> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRegExp)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRegExp"; } };


 QDataStream &operator<<(QDataStream &out, const QRegExp &regExp);
 QDataStream &operator>>(QDataStream &in, QRegExp &regExp);






#line 2 "../../include/QtCore/qregexp.h"
#line 29 "../../include/QtCore/../../src/corelib/tools/qstringlist.h"
#line 1 "../../include/QtCore/qstring.h"
#line 30 "../../include/QtCore/../../src/corelib/tools/qstringlist.h"
#line 1 "../../include/QtCore/qstringmatcher.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qstringmatcher.h"



















 




#line 1 "../../include/QtCore/qstring.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qstringmatcher.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class QStringMatcherPrivate;

class  QStringMatcher
{
public:
    QStringMatcher();
    QStringMatcher(const QString &pattern,
                   Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QStringMatcher(const QStringMatcher &other);
    ~QStringMatcher();

    QStringMatcher &operator=(const QStringMatcher &other);

    void setPattern(const QString &pattern);
    void setCaseSensitivity(Qt::CaseSensitivity cs);

    int indexIn(const QString &str, int from = 0) const;
    inline QString pattern() const { return q_pattern; }
    inline Qt::CaseSensitivity caseSensitivity() const { return q_cs; }

private:
    QStringMatcherPrivate *d_ptr;
    QString q_pattern;
    Qt::CaseSensitivity q_cs;
    uint q_skiptable[256];
};



#line 2 "../../include/QtCore/qstringmatcher.h"
#line 31 "../../include/QtCore/../../src/corelib/tools/qstringlist.h"






typedef QtValidLicenseForCoreModule QtCoreModule;

class QRegExp;

typedef QListIterator<QString> QStringListIterator;
typedef QMutableListIterator<QString> QMutableStringListIterator;

class QStringList : public QList<QString>
{
public:
    inline QStringList() { }
    inline explicit QStringList(const QString &i) { append(i); }
    inline QStringList(const QStringList &l) : QList<QString>(l) { }
    inline QStringList(const QList<QString> &l) : QList<QString>(l) { }

    inline void sort();

    inline QString join(const QString &sep) const;

    inline QStringList filter(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    inline QBool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    inline QStringList &replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    inline QStringList operator+(const QStringList &other) const
    { QStringList n = *this; n += other; return n; }
    inline QStringList &operator<<(const QString &str)
    { append(str); return *this; }
    inline QStringList &operator<<(const QStringList &l)
    { *this += l; return *this; }


    inline QStringList filter(const QRegExp &rx) const;
    inline QStringList &replaceInStrings(const QRegExp &rx, const QString &after);
    inline int indexOf(const QRegExp &rx, int from = 0) const;
    inline int lastIndexOf(const QRegExp &rx, int from = -1) const;





    inline int indexOf(const QString &str, int from = 0) const
    { return QList<QString>::indexOf(str, from); }
    inline int lastIndexOf(const QString &str, int from = -1) const
    { return QList<QString>::lastIndexOf(str, from); }


    static inline  QStringList split(const QString &sep, const QString &str, bool allowEmptyEntries = false);
    static inline  QStringList split(const QChar &sep, const QString &str, bool allowEmptyEntries = false);
    inline  QStringList grep(const QString &str, bool cs = true) const
        { return filter(str, cs ? Qt::CaseSensitive : Qt::CaseInsensitive); }


    static inline  QStringList split(const QRegExp &sep, const QString &str, bool allowEmptyEntries = false);
    inline  QStringList grep(const QRegExp &rx) const { return filter(rx); }
    inline  QStringList &gres(const QRegExp &rx, const QString &after)
        { return replaceInStrings(rx, after); }

    inline  QStringList &gres(const QString &before, const QString &after, bool cs = true)
        { return replaceInStrings(before, after, cs ? Qt::CaseSensitive : Qt::CaseInsensitive); }

    inline Iterator  fromLast() { return (isEmpty() ? end() : --end()); }
    inline ConstIterator  fromLast() const { return (isEmpty() ? end() : --end()); }

};

namespace QtPrivate {
    void  QStringList_sort(QStringList *that);
    QString  QStringList_join(const QStringList *that, const QString &sep);
    QStringList  QStringList_filter(const QStringList *that, const QString &str,
                                               Qt::CaseSensitivity cs);

    QBool  QStringList_contains(const QStringList *that, const QString &str, Qt::CaseSensitivity cs);
    void  QStringList_replaceInStrings(QStringList *that, const QString &before, const QString &after,
                                      Qt::CaseSensitivity cs);


    void  QStringList_replaceInStrings(QStringList *that, const QRegExp &rx, const QString &after);
    QStringList  QStringList_filter(const QStringList *that, const QRegExp &re);
    int  QStringList_indexOf(const QStringList *that, const QRegExp &rx, int from);
    int  QStringList_lastIndexOf(const QStringList *that, const QRegExp &rx, int from);

}

inline void QStringList::sort()
{
    QtPrivate::QStringList_sort(this);
}

inline QString QStringList::join(const QString &sep) const
{
    return QtPrivate::QStringList_join(this, sep);
}

inline QStringList QStringList::filter(const QString &str, Qt::CaseSensitivity cs) const
{
    return QtPrivate::QStringList_filter(this, str, cs);
}

inline QBool QStringList::contains(const QString &str, Qt::CaseSensitivity cs) const
{
    return QtPrivate::QStringList_contains(this, str, cs);
}

inline QStringList &QStringList::replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs)
{
    QtPrivate::QStringList_replaceInStrings(this, before, after, cs);
    return *this;
}


inline QStringList &QStringList::replaceInStrings(const QRegExp &rx, const QString &after)
{
    QtPrivate::QStringList_replaceInStrings(this, rx, after);
    return *this;
}

inline QStringList QStringList::filter(const QRegExp &rx) const
{
    return QtPrivate::QStringList_filter(this, rx);
}

inline int QStringList::indexOf(const QRegExp &rx, int from) const
{
    return QtPrivate::QStringList_indexOf(this, rx, from);
}

inline int QStringList::lastIndexOf(const QRegExp &rx, int from) const
{
    return QtPrivate::QStringList_lastIndexOf(this, rx, from);
}




inline QStringList QStringList::split(const QChar &sep, const QString &str, bool allowEmptyEntries)
{
    if (str.isEmpty())
        return QStringList();
    return str.split(sep, allowEmptyEntries ? QString::KeepEmptyParts
                                            : QString::SkipEmptyParts);
}

inline QStringList QStringList::split(const QString &sep, const QString &str, bool allowEmptyEntries)
{
    if (str.isEmpty())
        return QStringList();
    return str.split(sep, allowEmptyEntries ? QString::KeepEmptyParts
                                            : QString::SkipEmptyParts);
}


inline QStringList QStringList::split(const QRegExp &sep, const QString &str, bool allowEmptyEntries)
{
    if (str.isEmpty())
        return QStringList();
    return str.split(sep, allowEmptyEntries ? QString::KeepEmptyParts
                                            : QString::SkipEmptyParts);
}






inline QDataStream &operator>>(QDataStream &in, QStringList &list)
{
    return operator>>(in, static_cast<QList<QString> &>(list));
}
inline QDataStream &operator<<(QDataStream &out, const QStringList &list)
{
    return operator<<(out, static_cast<const QList<QString> &>(list));
}




#line 2 "../../include/QtCore/qstringlist.h"
#line 28 "../../include/QtGui/../../src/gui/painting/qcolor.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QColor;
class QColormap;
class QVariant;


 QDebug operator<<(QDebug, const QColor &);


 QDataStream &operator<<(QDataStream &, const QColor &);
 QDataStream &operator>>(QDataStream &, QColor &);


class  QColor
{
public:
    enum Spec { Invalid, Rgb, Hsv, Cmyk };

    QColor();
    QColor(Qt::GlobalColor color);
    QColor(int r, int g, int b, int a = 255);
    QColor(QRgb rgb);
    QColor(const QString& name);
    QColor(const char *name);
    QColor(const QColor &color);

    bool isValid() const;

    QString name() const;
    void setNamedColor(const QString& name);

    static QStringList colorNames();

    inline Spec spec() const
    { return cspec; }

    int alpha() const;
    void setAlpha(int alpha);

    qreal alphaF() const;
    void setAlphaF(qreal alpha);

    int red() const;
    int green() const;
    int blue() const;
    void setRed(int red);
    void setGreen(int green);
    void setBlue(int blue);

    qreal redF() const;
    qreal greenF() const;
    qreal blueF() const;
    void setRedF(qreal red);
    void setGreenF(qreal green);
    void setBlueF(qreal blue);

    void getRgb(int *r, int *g, int *b, int *a = 0) const;
    void setRgb(int r, int g, int b, int a = 255);

    void getRgbF(qreal *r, qreal *g, qreal *b, qreal *a = 0) const;
    void setRgbF(qreal r, qreal g, qreal b, qreal a = 1.0);

    QRgb rgba() const;
    void setRgba(QRgb rgba);

    QRgb rgb() const;
    void setRgb(QRgb rgb);

    int hue() const; 
    int saturation() const;
    int value() const;

    qreal hueF() const; 
    qreal saturationF() const;
    qreal valueF() const;

    void getHsv(int *h, int *s, int *v, int *a = 0) const;
    void setHsv(int h, int s, int v, int a = 255);

    void getHsvF(qreal *h, qreal *s, qreal *v, qreal *a = 0) const;
    void setHsvF(qreal h, qreal s, qreal v, qreal a = 1.0);

    int cyan() const;
    int magenta() const;
    int yellow() const;
    int black() const;

    qreal cyanF() const;
    qreal magentaF() const;
    qreal yellowF() const;
    qreal blackF() const;

    void getCmyk(int *c, int *m, int *y, int *k, int *a = 0);
    void setCmyk(int c, int m, int y, int k, int a = 255);

    void getCmykF(qreal *c, qreal *m, qreal *y, qreal *k, qreal *a = 0);
    void setCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0);

    QColor toRgb() const;
    QColor toHsv() const;
    QColor toCmyk() const;

    QColor convertTo(Spec colorSpec) const;

    static QColor fromRgb(QRgb rgb);
    static QColor fromRgba(QRgb rgba);

    static QColor fromRgb(int r, int g, int b, int a = 255);
    static QColor fromRgbF(qreal r, qreal g, qreal b, qreal a = 1.0);

    static QColor fromHsv(int h, int s, int v, int a = 255);
    static QColor fromHsvF(qreal h, qreal s, qreal v, qreal a = 1.0);

    static QColor fromCmyk(int c, int m, int y, int k, int a = 255);
    static QColor fromCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0);

    QColor light(int f = 150) const;
    QColor dark(int f = 200) const;

    QColor &operator=(const QColor &);
    QColor &operator=(Qt::GlobalColor color);

    bool operator==(const QColor &c) const;
    bool operator!=(const QColor &c) const;

    operator QVariant() const;


    inline explicit QColor(int x, int y, int z, Spec colorSpec)
    { if (colorSpec == Hsv) setHsv(x, y, z); else setRgb(x, y, z); }

    inline  void rgb(int *r, int *g, int *b) const
    { getRgb(r, g, b); }
    inline  void hsv(int *h, int *s, int *v) const
    { getHsv(h, s, v); }

    inline  void setRgba(int r, int g, int b, int a)
    { setRgb(r, g, b, a); }
    inline  void getRgba(int *r, int *g, int *b, int *a) const
    { getRgb(r, g, b, a); }

     uint pixel(int screen = -1) const;


private:





    void invalidate();

    Spec cspec;
    union {
        struct {
            ushort alpha;
            ushort red;
            ushort green;
            ushort blue;
            ushort pad;
        } argb;
        struct {
            ushort alpha;
            ushort hue;
            ushort saturation;
            ushort value;
            ushort pad;
        } ahsv;
        struct {
            ushort alpha;
            ushort cyan;
            ushort magenta;
            ushort yellow;
            ushort black;
        } acmyk;
    } ct;

    friend class QColormap;

    friend  QDataStream &operator<<(QDataStream &, const QColor &);
    friend  QDataStream &operator>>(QDataStream &, QColor &);

};

inline QColor::QColor()
{ invalidate(); }

inline QColor::QColor(int r, int g, int b, int a)
{ setRgb(r, g, b, a); }

inline QColor::QColor(const char *aname)
{ setNamedColor(QLatin1String(aname)); }

inline QColor::QColor(const QString& aname)
{ setNamedColor(aname); }

inline QColor::QColor(const QColor &acolor)
    : cspec(acolor.cspec)
{ ct.argb = acolor.ct.argb; }

inline bool QColor::isValid() const
{ return cspec != Invalid; }



#line 2 "../../include/QtGui/qcolor.h"
#line 26 "text/qtextformat.h"
#line 1 "../../include/QtGui/qfont.h"
#line 1 "../../include/QtGui/../../src/gui/text/qfont.h"



















 




#line 1 "../../include/QtGui/qwindowdefs.h"
#line 1 "../../include/QtGui/../../src/gui/kernel/qwindowdefs.h"



















 




#line 1 "../../include/QtCore/qobjectdefs.h"
#line 26 "../../include/QtGui/../../src/gui/kernel/qwindowdefs.h"
#line 1 "../../include/QtCore/qnamespace.h"
#line 27 "../../include/QtGui/../../src/gui/kernel/qwindowdefs.h"



typedef QtValidLicenseForGuiModule QtGuiModule;



class QPaintDevice;
class QWidget;
class QDialog;
class QColor;
class QPalette;

class QColorGroup;

class QCursor;
class QPoint;
class QSize;
class QRect;
class QPolygon;
class QPainter;
class QRegion;
class QFont;
class QFontMetrics;
class QFontInfo;
class QPen;
class QBrush;
class QMatrix;
class QPixmap;
class QBitmap;
class QMovie;
class QImage;
class QPicture;
class QPrinter;
class QTimer;
class QTime;
class QClipboard;
class QString;
class QByteArray;
class QApplication;

template<typename T> class QList;
typedef QList<QWidget *> QWidgetList;



#line 108 "../../include/QtGui/../../src/gui/kernel/qwindowdefs.h"











typedef struct _XDisplay Display;
typedef union  _XEvent XEvent;
typedef struct _XGC *GC;
typedef struct _XRegion *Region;
typedef unsigned long  WId;



#line 133 "../../include/QtGui/../../src/gui/kernel/qwindowdefs.h"

template<class K, class V> class QHash;
typedef QHash<WId, QWidget *> QWidgetMapper;









#line 2 "../../include/QtGui/qwindowdefs.h"
#line 26 "../../include/QtGui/../../src/gui/text/qfont.h"
#line 1 "../../include/QtCore/qstring.h"
#line 27 "../../include/QtGui/../../src/gui/text/qfont.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QFontPrivate;                                      
class QStringList;
class QVariant;
class Q3TextFormatCollection;

class  QFont
{
public:
    enum StyleHint {
        Helvetica,  SansSerif = Helvetica,
        Times,      Serif = Times,
        Courier,    TypeWriter = Courier,
        OldEnglish, Decorative = OldEnglish,
        System,
        AnyStyle
    };

    enum StyleStrategy {
        PreferDefault    = 0x0001,
        PreferBitmap     = 0x0002,
        PreferDevice     = 0x0004,
        PreferOutline    = 0x0008,
        ForceOutline     = 0x0010,
        PreferMatch      = 0x0020,
        PreferQuality    = 0x0040,
        PreferAntialias  = 0x0080,
        NoAntialias      = 0x0100,
        OpenGLCompatible = 0x0200
    };

    enum Weight {
        Light    = 25,
        Normal   = 50,
        DemiBold = 63,
        Bold     = 75,
        Black    = 87
    };

    enum Style {
        StyleNormal,
        StyleItalic,
        StyleOblique
    };

    enum Stretch {
        UltraCondensed =  50,
        ExtraCondensed =  62,
        Condensed      =  75,
        SemiCondensed  =  87,
        Unstretched    = 100,
        SemiExpanded   = 112,
        Expanded       = 125,
        ExtraExpanded  = 150,
        UltraExpanded  = 200
    };

    QFont();
    QFont(const QString &family, int pointSize = -1, int weight = -1, bool italic = false);
    QFont(const QFont &, QPaintDevice *pd);
    QFont(const QFont &);
    ~QFont();

    QString family() const;
    void setFamily(const QString &);

    int pointSize() const;
    void setPointSize(int);
    qreal pointSizeF() const;
    void setPointSizeF(qreal);

    int pixelSize() const;
    void setPixelSize(int);

    int weight() const;
    void setWeight(int);

    inline bool bold() const;
    inline void setBold(bool);

    void setStyle(Style style);
    Style style() const;

    inline bool italic() const;
    inline void setItalic(bool b);

    bool underline() const;
    void setUnderline(bool);

    bool overline() const;
    void setOverline(bool);

    bool strikeOut() const;
    void setStrikeOut(bool);

    bool fixedPitch() const;
    void setFixedPitch(bool);

    bool kerning() const;
    void setKerning(bool);

    StyleHint styleHint() const;
    StyleStrategy styleStrategy() const;
    void setStyleHint(StyleHint, StyleStrategy = PreferDefault);
    void setStyleStrategy(StyleStrategy s);

    int stretch() const;
    void setStretch(int);

    
    bool rawMode() const;
    void setRawMode(bool);

    
    bool exactMatch() const;

    QFont &operator=(const QFont &);
    bool operator==(const QFont &) const;
    bool operator!=(const QFont &) const;
    bool operator<(const QFont &) const;
    operator QVariant() const;
    bool isCopyOf(const QFont &) const;





    Qt::HANDLE handle() const;



    
    void setRawName(const QString &);
    QString rawName() const;

    QString key() const;

    QString toString() const;
    bool fromString(const QString &);

    static QString substitute(const QString &);
    static QStringList substitutes(const QString &);
    static QStringList substitutions();
    static void insertSubstitution(const QString&, const QString &);
    static void insertSubstitutions(const QString&, const QStringList &);
    static void removeSubstitution(const QString &);
    static void initialize();
    static void cleanup();

    static void cacheStatistics();


    QString defaultFamily() const;
    QString lastResortFamily() const;
    QString lastResortFont() const;

    QFont resolve(const QFont &) const;
    inline uint resolve() const { return resolve_mask; }
    inline void resolve(uint mask) { resolve_mask = mask; }


    static  QFont defaultFont();
    static  void setDefaultFont(const QFont &);
     void setPixelSizeFloat(qreal);
     qreal pointSizeFloat() const { return pointSizeF(); }
     void setPointSizeFloat(qreal size) { setPointSizeF(size); }


private:
    QFont(QFontPrivate *);

    void detach();





    void x11SetScreen(int screen = -1);
    int x11Screen() const;


    friend class QFontMetrics;
    friend class QFontMetricsF;
    friend class QFontInfo;
    friend class QPainter;
    friend class QPSPrintEngineFont;
    friend class QApplication;
    friend class QWidget;
    friend class QWidgetPrivate;
    friend class Q3TextFormatCollection;
    friend class QTextLayout;
    friend class QTextEngine;
    friend class QTextLine;
    friend struct QScriptLine;
    friend class QGLContext;
    friend class QWin32PaintEngine;
    friend class QPainterPath;


    friend  QDataStream &operator<<(QDataStream &, const QFont &);
    friend  QDataStream &operator>>(QDataStream &, QFont &);


    QFontPrivate *d;
    uint resolve_mask;
};


inline bool QFont::bold() const
{ return weight() > Normal; }


inline void QFont::setBold(bool enable)
{ setWeight(enable ? Bold : Normal); }

inline bool QFont::italic() const
{
    return (style() != StyleNormal);
}

inline void QFont::setItalic(bool b) {
    setStyle(b ? StyleItalic : StyleNormal);
}




 


 QDataStream &operator<<(QDataStream &, const QFont &);
 QDataStream &operator>>(QDataStream &, QFont &);




#line 2 "../../include/QtGui/qfont.h"
#line 27 "text/qtextformat.h"
#line 1 "../../include/QtCore/qshareddata.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qshareddata.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qshareddata.h"
#line 1 "../../include/QtCore/qatomic.h"
#line 27 "../../include/QtCore/../../src/corelib/tools/qshareddata.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

template <class T> class QSharedDataPointer;

class  QSharedData
{
public:
    QAtomic ref;

    inline QSharedData() : ref(0) { }
    inline QSharedData(const QSharedData &) : ref(0) { }

private:
    
    QSharedData &operator=(const QSharedData &);
};

template <class T> class QSharedDataPointer
{
public:
    inline void detach() { if (d && d->ref != 1) detach_helper(); }
    inline T &operator*() { detach(); return *d; }
    inline const T &operator*() const { return *d; }
    inline T *operator->() { detach(); return d; }
    inline const T *operator->() const { return d; }
    inline operator T *() { detach(); return d; }
    inline operator const T *() const { return d; }
    inline T *data() { detach(); return d; }
    inline const T *data() const { return d; }
    inline const T *constData() const { return d; }

    inline bool operator==(const QSharedDataPointer<T> &other) const { return d == other.d; }
    inline bool operator!=(const QSharedDataPointer<T> &other) const { return d != other.d; }

    inline QSharedDataPointer() { d = 0; }
    inline ~QSharedDataPointer() { if (d && !d->ref.deref()) delete d; }

    explicit QSharedDataPointer(T *data);
    inline QSharedDataPointer(const QSharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }
    inline QSharedDataPointer<T> & operator=(const QSharedDataPointer<T> &o) {
        if (o.d != d) {
            T *x = o.d;
            if (x) x->ref.ref();
            x = qAtomicSetPtr(&d, x);
            if (x && !x->ref.deref())
                delete x;
        }
        return *this;
    }
    inline QSharedDataPointer &operator=(T *o) {
        if (o != d) {
            T *x = o;
            if (x) x->ref.ref();
            x = qAtomicSetPtr(&d, x);
            if (x && !x->ref.deref())
                delete x;
        }
        return *this;
    }

    inline bool operator!() const { return !d; }

private:
    void detach_helper();

    T *d;
};

template <class T>
inline QSharedDataPointer<T>::QSharedDataPointer(T *adata) : d(adata)
{ if (d) d->ref.ref(); }

template <class T>
 void QSharedDataPointer<T>::detach_helper()
{
    T *x = new T(*d);
    x->ref.ref();
    x = qAtomicSetPtr(&d, x);
    if (!x->ref.deref())
        delete x;
}



#line 2 "../../include/QtCore/qshareddata.h"
#line 28 "text/qtextformat.h"
#line 1 "../../include/QtCore/qvector.h"
#line 29 "text/qtextformat.h"
#line 1 "../../include/QtCore/qvariant.h"
#line 1 "../../include/QtCore/../../src/corelib/kernel/qvariant.h"



















 




#line 1 "../../include/QtCore/qatomic.h"
#line 26 "../../include/QtCore/../../src/corelib/kernel/qvariant.h"
#line 1 "../../include/QtCore/qbytearray.h"
#line 27 "../../include/QtCore/../../src/corelib/kernel/qvariant.h"
#line 1 "../../include/QtCore/qlist.h"
#line 28 "../../include/QtCore/../../src/corelib/kernel/qvariant.h"
#line 1 "../../include/QtCore/qmetatype.h"
#line 1 "../../include/QtCore/../../src/corelib/kernel/qmetatype.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtCore/../../src/corelib/kernel/qmetatype.h"
#line 1 "../../include/QtCore/qatomic.h"
#line 27 "../../include/QtCore/../../src/corelib/kernel/qmetatype.h"

#line 1 "../../include/QtCore/qdatastream.h"
#line 30 "../../include/QtCore/../../src/corelib/kernel/qmetatype.h"








typedef QtValidLicenseForCoreModule QtCoreModule;

class  QMetaType {
public:
    enum Type {
        
        Void = 0, Bool = 1, Int = 2, UInt = 3, Double = 6, QChar = 7,
        QString = 10, QByteArray = 12,

        VoidStar = 128, Long, Short, Char, ULong,
        UShort, UChar, Float, QObjectStar, QWidgetStar,
        User = 256
    };

    typedef void (*Destructor)(void *);
    typedef void *(*Constructor)(const void *);


    typedef void (*SaveOperator)(QDataStream &, const void *);
    typedef void (*LoadOperator)(QDataStream &, void *);
    static void registerStreamOperators(const char *typeName, SaveOperator saveOp,
                                        LoadOperator loadOp);

    static int registerType(const char *typeName, Destructor destructor,
                            Constructor constructor);
    static int type(const char *typeName);
    static const char *typeName(int type);
    static bool isRegistered(int type);
    static void *construct(int type, const void *copy);
    static void destroy(int type, void *data);


    static bool save(QDataStream &stream, int type, const void *data);
    static bool load(QDataStream &stream, int type, void *data);

};

template <typename T>
void qMetaTypeDeleteHelper(T *t)
{
    delete t;
}

template <typename T>
void *qMetaTypeConstructHelper(const T *t)
{
    if (!t)
        return new T;
    return new T(*static_cast<const T*>(t));
}

template <typename T>
int qRegisterMetaType(const char *typeName

    , T *   = 0

)
{
    typedef void*(*ConstructPtr)(const T*);
    ConstructPtr cptr = qMetaTypeConstructHelper<T>;
    typedef void(*DeletePtr)(T*);
    DeletePtr dptr = qMetaTypeDeleteHelper<T>;

    return QMetaType::registerType(typeName, reinterpret_cast<QMetaType::Destructor>(dptr),
                                   reinterpret_cast<QMetaType::Constructor>(cptr));
}


template <typename T>
void qMetaTypeSaveHelper(QDataStream &stream, const T *t)
{
    stream << *t;
}

template <typename T>
void qMetaTypeLoadHelper(QDataStream &stream, T *t)
{
    stream >> *t;
}

template <typename T>
void qRegisterMetaTypeStreamOperators(const char *typeName

    , T *   = 0

)
{
    typedef void(*SavePtr)(QDataStream &, const T *);
    typedef void(*LoadPtr)(QDataStream &, T *);
    SavePtr sptr = qMetaTypeSaveHelper<T>;
    LoadPtr lptr = qMetaTypeLoadHelper<T>;

    qRegisterMetaType<T>(typeName);
    QMetaType::registerStreamOperators(typeName, reinterpret_cast<QMetaType::SaveOperator>(sptr),
                                       reinterpret_cast<QMetaType::LoadOperator>(lptr));
}


template <typename T>
struct QMetaTypeId
{
    enum { Defined = 0 };
};

template <typename T>
inline int qMetaTypeId(

    T *   = 0

)
{
    return QMetaTypeId<T>::qt_metatype_id();
}

#line 165 "../../include/QtCore/../../src/corelib/kernel/qmetatype.h"

class QString;
template<> struct QMetaTypeId<QString>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::QString; } };
template<> struct QMetaTypeId<int>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::Int; } };
template<> struct QMetaTypeId<uint>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::UInt; } };
template<> struct QMetaTypeId<bool>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::Bool; } };
template<> struct QMetaTypeId<double>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::Double; } };
class QByteArray;
template<> struct QMetaTypeId<QByteArray>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::QByteArray; } };
class QChar;
template<> struct QMetaTypeId<QChar>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::QChar; } };
template<> struct QMetaTypeId<void>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::Void; } };
template<> struct QMetaTypeId<long>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::Long; } };
template<> struct QMetaTypeId<short>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::Short; } };
template<> struct QMetaTypeId<char>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::Char; } };
template<> struct QMetaTypeId<ulong>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::ULong; } };
template<> struct QMetaTypeId<ushort>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::UShort; } };
template<> struct QMetaTypeId<uchar>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::UChar; } };
template<> struct QMetaTypeId<float>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::Float; } };
class QObject;
template<> struct QMetaTypeId<QObject *>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::QObjectStar; } };
class QWidget;
template<> struct QMetaTypeId<QWidget *>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::QWidgetStar; } };
template<> struct QMetaTypeId<void *>
{ enum { Defined = 1 };
  static inline int qt_metatype_id() { return QMetaType::VoidStar; } };



#line 2 "../../include/QtCore/qmetatype.h"
#line 29 "../../include/QtCore/../../src/corelib/kernel/qvariant.h"
#line 1 "../../include/QtCore/qmap.h"
#line 30 "../../include/QtCore/../../src/corelib/kernel/qvariant.h"
#line 1 "../../include/QtCore/qstring.h"
#line 31 "../../include/QtCore/../../src/corelib/kernel/qvariant.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class QBitArray;
class QDataStream;
class QDate;
class QDateTime;
class QLine;
class QLineF;
class QLocale;
class QStringList;
class QTime;
class QPoint;
class QPointF;
class QSize;
class QSizeF;
class QRect;
class QRectF;
class QRegExp;
class QTextFormat;
class QTextLength;
class QUrl;
class QVariant;
class QVariantComparisonHelper;


template <typename T>
inline QVariant qVariantFromValue(const T &);

template <typename T>
inline void qVariantSetValue(QVariant &, const T &);

template<typename T>
inline T qVariantValue(const QVariant &);

template<typename T>
inline bool qVariantCanConvert(const QVariant &);


class  QVariant
{
 public:
    enum Type {
        Invalid = 0,

        Bool = 1,
        Int = 2,
        UInt = 3,
        LongLong = 4,
        ULongLong = 5,
        Double = 6,
        Char = 7,
        Map = 8,
        List = 9,
        String = 10,
        StringList = 11,
        ByteArray = 12,
        BitArray = 13,
        Date = 14,
        Time = 15,
        DateTime = 16,
        Url = 17,
        Locale = 18,
        Rect = 19,
        RectF = 20,
        Size = 21,
        SizeF = 22,
        Line = 23,
        LineF = 24,
        Point = 25,
        PointF = 26,
	RegExp = 27,


        ColorGroup = 63,

        Font = 64,
        Pixmap = 65,
        Brush = 66,
        Color = 67,
        Palette = 68,
        Icon = 69,
        Image = 70,
        Polygon = 71,
        Region = 72,
        Bitmap = 73,
        Cursor = 74,
        SizePolicy = 75,
        KeySequence = 76,
        Pen = 77,
        TextLength = 78,
        TextFormat = 79,
        UserType = 127,

        IconSet = Icon,
        CString = ByteArray,
        PointArray = Polygon,

        LastType = 0xffffffff 
    };

    inline QVariant();
    ~QVariant();
    QVariant(Type type);
    QVariant(int typeOrUserType, const void *copy);
    QVariant(const QVariant &other);


    QVariant(QDataStream &s);


    QVariant(int i);
    QVariant(uint ui);
    QVariant(qlonglong ll);
    QVariant(qulonglong ull);
    QVariant(bool b);
    QVariant(double d);

    QVariant(const char *str);


    QVariant(const QByteArray &bytearray);
    QVariant(const QBitArray &bitarray);
    QVariant(const QString &string);
    QVariant(const QLatin1String &string);
    QVariant(const QStringList &stringlist);
    QVariant(const QChar &qchar);
    QVariant(const QDate &date);
    QVariant(const QTime &time);
    QVariant(const QDateTime &datetime);
    QVariant(const QList<QVariant> &list);
    QVariant(const QMap<QString,QVariant> &map);

    QVariant(const QSize &size);
    QVariant(const QSizeF &size);
    QVariant(const QPoint &pt);
    QVariant(const QPointF &pt);
    QVariant(const QLine &line);
    QVariant(const QLineF &line);
    QVariant(const QRect &rect);
    QVariant(const QRectF &rect);

    QVariant(const QUrl &url);
    QVariant(const QLocale &locale);
    QVariant(const QRegExp &regExp);

    QVariant& operator=(const QVariant &other);

    Type type() const;
    int userType() const;
    const char *typeName() const;

    bool canConvert(Type t) const;
    bool convert(Type t);


    inline  bool canCast(Type t) const
    { return canConvert(t); }
    inline  bool cast(Type t)
    { return convert(t); }


    inline bool isValid() const;
    bool isNull() const;

    void clear();

    void detach();
    inline bool isDetached() const;

    int toInt(bool *ok = 0) const;
    uint toUInt(bool *ok = 0) const;
    qlonglong toLongLong(bool *ok = 0) const;
    qulonglong toULongLong(bool *ok = 0) const;
    bool toBool() const;
    double toDouble(bool *ok = 0) const;
    QByteArray toByteArray() const;
    QBitArray toBitArray() const;
    QString toString() const;
    QStringList toStringList() const;
    QChar toChar() const;
    QDate toDate() const;
    QTime toTime() const;
    QDateTime toDateTime() const;
    QList<QVariant> toList() const;
    QMap<QString, QVariant> toMap() const;


    QPoint toPoint() const;
    QPointF toPointF() const;
    QRect toRect() const;
    QSize toSize() const;
    QSizeF toSizeF() const;
    QLine toLine() const;
    QLineF toLineF() const;
    QRectF toRectF() const;

    QUrl toUrl() const;
    QLocale toLocale() const;
    QRegExp toRegExp() const;


    inline  int &asInt();
    inline  uint &asUInt();
    inline  qlonglong &asLongLong();
    inline  qulonglong &asULongLong();
    inline  bool &asBool();
    inline  double &asDouble();
    inline  QByteArray &asByteArray();
    inline  QBitArray &asBitArray();
    inline  QString &asString();
    inline  QStringList &asStringList();
    inline  QDate &asDate();
    inline  QTime &asTime();
    inline  QDateTime &asDateTime();
    inline  QList<QVariant> &asList();
    inline  QMap<QString,QVariant> &asMap();
    inline  QPoint &asPoint();
    inline  QRect &asRect();
    inline  QSize &asSize();



    void load(QDataStream &ds);
    void save(QDataStream &ds) const;

    static const char *typeToName(Type type);
    static Type nameToType(const char *name);


    inline explicit QVariant(bool val, int) { create(Bool, &val); }
    inline  const QByteArray toCString() const { return toByteArray(); }
    inline  QByteArray &asCString() { return *reinterpret_cast<QByteArray *>(castOrDetach(ByteArray)); }


    void *data();
    const void *constData() const;
    inline const void *data() const { return constData(); }


    template<typename T>
    inline void setValue(const T &value);

    template<typename T>
    inline T value() const
    { return qVariantValue<T>(*this); }

    template<typename T>
    static inline QVariant fromValue(const T &value)
    { return qVariantFromValue(value); }

    template<typename T>
    bool canConvert() const
    { return qVariantCanConvert<T>(*this); }


 public:

    struct PrivateShared
    {
        inline PrivateShared() : ref(1) { }
        inline PrivateShared(void *v) : ref(1) { ptr = v; }
        void *ptr;
        QAtomic ref;
    };
    struct Private
    {
        inline Private(): type(Invalid), is_shared(false), is_null(true) { data.ptr = 0; }
        inline Private(const Private &other)
            : data(other.data), type(other.type),
              is_shared(other.is_shared), is_null(other.is_null)
        {}
        union Data
        {
            int i;
            uint u;
            bool b;
            double d;
            qlonglong ll;
            qulonglong ull;
            void *ptr;
            PrivateShared *shared;
        } data;
        uint type : 30;
        uint is_shared : 1;
        uint is_null : 1;
    };
 public:
    typedef void (*f_construct)(Private *, const void *);
    typedef void (*f_clear)(Private *);
    typedef bool (*f_null)(const Private *);

    typedef void (*f_load)(Private *, QDataStream &);
    typedef void (*f_save)(const Private *, QDataStream &);

    typedef bool (*f_compare)(const Private *, const Private *);
    typedef bool (*f_convert)(const QVariant::Private *d, Type t, void *, bool *);
    typedef bool (*f_canConvert)(const QVariant::Private *d, Type t);
    typedef void (*f_debugStream)(QDebug, const QVariant &);
    struct Handler {
        f_construct construct;
        f_clear clear;
        f_null isNull;

        f_load load;
        f_save save;

        f_compare compare;
        f_convert convert;
        f_canConvert canConvert;
        f_debugStream debugStream;
    };


    inline bool operator==(const QVariant &v) const
    { return cmp(v); }
    inline bool operator!=(const QVariant &v) const
    { return !cmp(v); }

protected:
    friend inline bool qvariant_cast_helper(const QVariant &, QVariant::Type, void *);
    friend int qRegisterGuiVariant();
    friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);

    friend  QDebug operator<<(QDebug, const QVariant &);

    Private d;


    static const Handler *handler;


    void create(int type, const void *copy);

    void *castOrDetach(Type t);

    bool cmp(const QVariant &other) const;

private:
#line 380 "../../include/QtCore/../../src/corelib/kernel/qvariant.h"
};


typedef QList<QVariant> QVariantList;
typedef QMap<QString, QVariant> QVariantMap;

inline bool qvariant_cast_helper(const QVariant &v, QVariant::Type tp, void *ptr)
{ return QVariant::handler->convert(&v.d, tp, ptr, 0); }

template <typename T>
inline int qt_variant_metatype_id(T *)
{ return QMetaTypeId<T>::qt_metatype_id(); }

template<>
inline int qt_variant_metatype_id(QVariantMap *) { return QVariant::Map; }
template<>
inline int qt_variant_metatype_id(QVariantList *) { return QVariant::List; }
template<>
inline int qt_variant_metatype_id(QStringList *) { return QVariant::StringList; }
class QFont;
template<>
inline int qt_variant_metatype_id(QFont *) { return QVariant::Font; }
class QPixmap;
template<>
inline int qt_variant_metatype_id(QPixmap *) { return QVariant::Pixmap; }
class QBrush;
template<>
inline int qt_variant_metatype_id(QBrush *) { return QVariant::Brush; }
template<>
inline int qt_variant_metatype_id(QRect *) { return QVariant::Rect; }
template<>
inline int qt_variant_metatype_id(QSize *) { return QVariant::Size; }
template<>
inline int qt_variant_metatype_id(QSizeF *) { return QVariant::SizeF; }
class QColor;
template<>
inline int qt_variant_metatype_id(QColor *) { return QVariant::Color; }
class QPalette;
template<>
inline int qt_variant_metatype_id(QPalette *) { return QVariant::Palette; }
class QIcon;
template<>
inline int qt_variant_metatype_id(QIcon *) { return QVariant::Icon; }
class QPoint;
template<>
inline int qt_variant_metatype_id(QPoint *) { return QVariant::Point; }
class QPointF;
template<>
inline int qt_variant_metatype_id(QPointF *) { return QVariant::PointF; }
class QImage;
template<>
inline int qt_variant_metatype_id(QImage*) { return QVariant::Image; }
class QPolygon;
template<>
inline int qt_variant_metatype_id(QPolygon *) { return QVariant::Polygon; }
class QRegion;
template<>
inline int qt_variant_metatype_id(QRegion *) { return QVariant::Region; }
class QBitmap;
template<>
inline int qt_variant_metatype_id(QBitmap *) { return QVariant::Bitmap; }
class QCursor;
template<>
inline int qt_variant_metatype_id(QCursor *) { return QVariant::Cursor; }
class QSizePolicy;
template<>
inline int qt_variant_metatype_id(QSizePolicy *) { return QVariant::SizePolicy; }
template<>
inline int qt_variant_metatype_id(QDate *) { return QVariant::Date; }
template<>
inline int qt_variant_metatype_id(QTime *) { return QVariant::Time; }
template<>
inline int qt_variant_metatype_id(QDateTime *) { return QVariant::DateTime; }
template<>
inline int qt_variant_metatype_id(QBitArray *) { return QVariant::BitArray; }
class QKeySequence;
template<>
inline int qt_variant_metatype_id(QKeySequence *) { return QVariant::KeySequence; }
class QPen;
template<>
inline int qt_variant_metatype_id(QPen *) { return QVariant::Pen; }
template<>
inline int qt_variant_metatype_id(qlonglong *) { return QVariant::LongLong; }
template<>
inline int qt_variant_metatype_id(qulonglong *) { return QVariant::ULongLong; }
template<>
inline int qt_variant_metatype_id(QUrl *) { return QVariant::Url; }
class QTextLength;
template<>
inline int qt_variant_metatype_id(QTextLength *) { return QVariant::TextLength; }
class QTextFormat;
template<>
inline int qt_variant_metatype_id(QTextFormat *) { return QVariant::TextFormat; }
template<>
inline int qt_variant_metatype_id(QLocale *) { return QVariant::Locale; }
template<>
inline int qt_variant_metatype_id(QRegExp *) { return QVariant::RegExp; }
template<>
inline int qt_variant_metatype_id(QLineF *) { return QVariant::LineF; }
template<>
inline int qt_variant_metatype_id(QLine *) { return QVariant::Line; }
template<>
inline int qt_variant_metatype_id(QRectF *) { return QVariant::RectF; }

class QColorGroup;
template<>
inline int qt_variant_metatype_id(QColorGroup *) { return QVariant::ColorGroup; }


template <typename T>
inline QVariant qVariantFromValue(const T &t)
{
    return QVariant(qt_variant_metatype_id<T>(reinterpret_cast<T *>(0)), &t);
}

template <>
inline QVariant qVariantFromValue(const QVariant &t) { return t; }

template <typename T>
inline void qVariantSetValue(QVariant &v, const T &t)
{
    v = QVariant(qt_variant_metatype_id<T>(reinterpret_cast<T *>(0)), &t);
}


inline QVariant::QVariant() {}
inline bool QVariant::isValid() const { return d.type != Invalid; }


inline int &QVariant::asInt()
{ return *reinterpret_cast<int *>(castOrDetach(Int)); }
inline uint &QVariant::asUInt()
{ return *reinterpret_cast<uint *>(castOrDetach(UInt)); }
inline qlonglong &QVariant::asLongLong()
{ return *reinterpret_cast<qlonglong *>(castOrDetach(LongLong)); }
inline qulonglong &QVariant::asULongLong()
{ return *reinterpret_cast<qulonglong *>(castOrDetach(ULongLong)); }
inline bool &QVariant::asBool()
{ return *reinterpret_cast<bool *>(castOrDetach(Bool)); }
inline double &QVariant::asDouble()
{ return *reinterpret_cast<double *>(castOrDetach(Double)); }
inline QByteArray& QVariant::asByteArray()
{ return *reinterpret_cast<QByteArray *>(castOrDetach(ByteArray)); }
inline QBitArray& QVariant::asBitArray()
{ return *reinterpret_cast<QBitArray *>(castOrDetach(BitArray)); }
inline QString& QVariant::asString()
{ return *reinterpret_cast<QString *>(castOrDetach(String)); }
inline QStringList& QVariant::asStringList()
{ return *reinterpret_cast<QStringList *>(castOrDetach(StringList)); }
inline QDate& QVariant::asDate()
{ return *reinterpret_cast<QDate *>(castOrDetach(Date)); }
inline QTime& QVariant::asTime()
{ return *reinterpret_cast<QTime *>(castOrDetach(Time)); }
inline QDateTime& QVariant::asDateTime()
{ return *reinterpret_cast<QDateTime *>(castOrDetach(DateTime)); }
inline QList<QVariant>& QVariant::asList()
{ return *reinterpret_cast<QList<QVariant> *>(castOrDetach(List)); }
inline QMap<QString, QVariant>& QVariant::asMap()
{ return *reinterpret_cast<QMap<QString, QVariant> *>(castOrDetach(Map)); }
inline QPoint &QVariant::asPoint()
{ return *reinterpret_cast<QPoint *>(castOrDetach(Point)); }
inline QRect &QVariant::asRect()
{ return *reinterpret_cast<QRect *>(castOrDetach(Rect)); }
inline QSize &QVariant::asSize()
{ return *reinterpret_cast<QSize *>(castOrDetach(Size)); }



template<typename T>
inline void QVariant::setValue(const T &avalue)
{ qVariantSetValue(*this, avalue); }



 QDataStream& operator>> (QDataStream& s, QVariant& p);
 QDataStream& operator<< (QDataStream& s, const QVariant& p);
 QDataStream& operator>> (QDataStream& s, QVariant::Type& p);
 QDataStream& operator<< (QDataStream& s, const QVariant::Type p);


inline bool QVariant::isDetached() const
{ return !d.is_shared || d.data.shared->ref == 1; }









 
class QVariantComparisonHelper
{
public:
    inline QVariantComparisonHelper(const QVariant &var)
        : v(&var) {}
private:
    friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);
    const QVariant *v;
};

inline bool operator==(const QVariant &v1, const QVariantComparisonHelper &v2)
{
    return v1.cmp(*v2.v);
}

inline bool operator!=(const QVariant &v1, const QVariantComparisonHelper &v2)
{
    return !operator==(v1, v2);
}


#line 619 "../../include/QtCore/../../src/corelib/kernel/qvariant.h"

template<typename T> T qvariant_cast(const QVariant &v)
{
    const int vid = qt_variant_metatype_id<T>(static_cast<T *>(0));
    if (vid == v.userType())
        return *reinterpret_cast<const T *>(v.constData());
    if (vid < int(QVariant::UserType)) {
        T t;
        qvariant_cast_helper(v, QVariant::Type(vid), &t);
        return t;
    }
    return T();
}

template<typename T>
inline T qVariantValue(const QVariant &variant)
{ return qvariant_cast<T>(variant); }

template<typename T>
inline bool qVariantCanConvert(const QVariant &variant)
{
    return variant.canConvert(static_cast<QVariant::Type>(
                qt_variant_metatype_id<T>(static_cast<T *>(0))));
}


template <> inline bool qIsDetached<QVariant>(QVariant &t) { return t . isDetached(); }
template <> class QTypeInfo<QVariant> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QVariant)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QVariant"; } };


 QDebug operator<<(QDebug, const QVariant &);
 QDebug operator<<(QDebug, const QVariant::Type);




#line 2 "../../include/QtCore/qvariant.h"
#line 30 "text/qtextformat.h"
#line 1 "../../include/QtGui/qpen.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qpen.h"



















 




#line 1 "../../include/QtGui/qcolor.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qpen.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QVariant;
class QPenPrivate;
class QBrush;
class QPen;


 QDataStream &operator<<(QDataStream &, const QPen &);
 QDataStream &operator>>(QDataStream &, QPen &);


class  QPen
{
public:
    QPen();
    QPen(Qt::PenStyle);
    QPen(const QColor &color);
    QPen(const QBrush &brush, qreal width, Qt::PenStyle s = Qt::SolidLine,
         Qt::PenCapStyle c = Qt::SquareCap, Qt::PenJoinStyle j = Qt::BevelJoin);
    QPen(const QPen &pen);

    ~QPen();

    QPen &operator=(const QPen &pen);

    Qt::PenStyle style() const;
    void setStyle(Qt::PenStyle);

    QVector<qreal> dashPattern() const;
    void setDashPattern(const QVector<qreal> &pattern);

    qreal miterLimit() const;
    void setMiterLimit(qreal limit);

    qreal widthF() const;
    void setWidthF(qreal width);

    int width() const;
    void setWidth(int width);

    QColor color() const;
    void setColor(const QColor &color);

    QBrush brush() const;
    void setBrush(const QBrush &brush);

    bool isSolid() const;

    Qt::PenCapStyle capStyle() const;
    void setCapStyle(Qt::PenCapStyle pcs);

    Qt::PenJoinStyle joinStyle() const;
    void setJoinStyle(Qt::PenJoinStyle pcs);

    bool operator==(const QPen &p) const;
    inline bool operator!=(const QPen &p) const { return !(operator==(p)); }
    operator QVariant() const;

    bool isDetached();
private:
    friend class QPainter;
    friend  QDataStream &operator>>(QDataStream &, QPen &);
    friend  QDataStream &operator<<(QDataStream &, const QPen &);

    void detach();
    class QPenPrivate *d;
};
template <> class QTypeInfo<QPen> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPen)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPen"; } };
template <> inline bool qIsDetached<QPen>(QPen &t) { return t . isDetached(); }


 QDebug operator<<(QDebug, const QPen &);




#line 2 "../../include/QtGui/qpen.h"
#line 31 "text/qtextformat.h"
#line 1 "../../include/QtGui/qbrush.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qbrush.h"



















 




#line 1 "../../include/QtCore/qpair.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qbrush.h"
#line 1 "../../include/QtCore/qpoint.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qpoint.h"



















 




#line 1 "../../include/QtCore/qnamespace.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qpoint.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class  QPoint
{
public:
    QPoint();
    QPoint(int xpos, int ypos);

    bool isNull() const;

    int x() const;
    int y() const;
    void setX(int x);
    void setY(int y);

    int manhattanLength() const;

    int &rx();
    int &ry();

    QPoint &operator+=(const QPoint &p);
    QPoint &operator-=(const QPoint &p);
    QPoint &operator*=(qreal c);
    QPoint &operator/=(qreal c);

    friend inline bool operator==(const QPoint &, const QPoint &);
    friend inline bool operator!=(const QPoint &, const QPoint &);
    friend inline const QPoint operator+(const QPoint &, const QPoint &);
    friend inline const QPoint operator-(const QPoint &, const QPoint &);
    friend inline const QPoint operator*(const QPoint &, qreal);
    friend inline const QPoint operator*(qreal, const QPoint &);
    friend inline const QPoint operator-(const QPoint &);
    friend inline const QPoint operator/(const QPoint &, qreal);

private:





    int xp;
    int yp;

};

template <> class QTypeInfo<QPoint> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPoint)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPoint"; } };



 

 QDataStream &operator<<(QDataStream &, const QPoint &);
 QDataStream &operator>>(QDataStream &, QPoint &);




 

inline QPoint::QPoint()
{ xp=0; yp=0; }

inline QPoint::QPoint(int xpos, int ypos)
{ xp = xpos; yp = ypos; }

inline bool QPoint::isNull() const
{ return xp == 0 && yp == 0; }

inline int QPoint::x() const
{ return xp; }

inline int QPoint::y() const
{ return yp; }

inline void QPoint::setX(int xpos)
{ xp = xpos; }

inline void QPoint::setY(int ypos)
{ yp = ypos; }

inline int &QPoint::rx()
{ return xp; }

inline int &QPoint::ry()
{ return yp; }

inline QPoint &QPoint::operator+=(const QPoint &p)
{ xp+=p.xp; yp+=p.yp; return *this; }

inline QPoint &QPoint::operator-=(const QPoint &p)
{ xp-=p.xp; yp-=p.yp; return *this; }

inline QPoint &QPoint::operator*=(qreal c)
{ xp = qRound(xp*c); yp = qRound(yp*c); return *this; }

inline bool operator==(const QPoint &p1, const QPoint &p2)
{ return p1.xp == p2.xp && p1.yp == p2.yp; }

inline bool operator!=(const QPoint &p1, const QPoint &p2)
{ return p1.xp != p2.xp || p1.yp != p2.yp; }

inline const QPoint operator+(const QPoint &p1, const QPoint &p2)
{ return QPoint(p1.xp+p2.xp, p1.yp+p2.yp); }

inline const QPoint operator-(const QPoint &p1, const QPoint &p2)
{ return QPoint(p1.xp-p2.xp, p1.yp-p2.yp); }

inline const QPoint operator*(const QPoint &p, qreal c)
{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); }

inline const QPoint operator*(qreal c, const QPoint &p)
{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); }

inline const QPoint operator-(const QPoint &p)
{ return QPoint(-p.xp, -p.yp); }

inline QPoint &QPoint::operator/=(qreal c)
{
    do {if(!(!qFuzzyCompare(c, 0)))qt_assert("!qFuzzyCompare(c, 0)","../../include/QtCore/../../src/corelib/tools/qpoint.h",147);} while (0);
    xp = qRound(xp/c);
    yp = qRound(yp/c);
    return *this;
}

inline const QPoint operator/(const QPoint &p, qreal c)
{
    do {if(!(!qFuzzyCompare(c, 0)))qt_assert("!qFuzzyCompare(c, 0)","../../include/QtCore/../../src/corelib/tools/qpoint.h",155);} while (0);
    return QPoint(qRound(p.xp/c), qRound(p.yp/c));
}


 QDebug operator<<(QDebug, const QPoint &);






class  QPointF
{
public:
    QPointF();
    QPointF(const QPoint &p);
    QPointF(qreal xpos, qreal ypos);

    bool isNull() const;

    qreal x() const;
    qreal y() const;
    void setX(qreal x);
    void setY(qreal y);

    qreal &rx();
    qreal &ry();

    QPointF &operator+=(const QPointF &p);
    QPointF &operator-=(const QPointF &p);
    QPointF &operator*=(qreal c);
    QPointF &operator/=(qreal c);

    friend inline bool operator==(const QPointF &, const QPointF &);
    friend inline bool operator!=(const QPointF &, const QPointF &);
    friend inline const QPointF operator+(const QPointF &, const QPointF &);
    friend inline const QPointF operator-(const QPointF &, const QPointF &);
    friend inline const QPointF operator*(qreal, const QPointF &);
    friend inline const QPointF operator*(const QPointF &, qreal);
    friend inline const QPointF operator-(const QPointF &);
    friend inline const QPointF operator/(const QPointF &, qreal);

    QPoint toPoint() const;

private:
    friend class QMatrix;

    qreal xp;
    qreal yp;
};

template <> class QTypeInfo<QPointF> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPointF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPointF"; } };



 

 QDataStream &operator<<(QDataStream &, const QPointF &);
 QDataStream &operator>>(QDataStream &, QPointF &);




 

inline QPointF::QPointF() : xp(0), yp(0) { }

inline QPointF::QPointF(qreal xpos, qreal ypos) : xp(xpos), yp(ypos) { }

inline QPointF::QPointF(const QPoint &p) : xp(p.x()), yp(p.y()) { }

inline bool QPointF::isNull() const
{
    return qIsNull(xp) && qIsNull(yp);
}

inline qreal QPointF::x() const
{
    return xp;
}

inline qreal QPointF::y() const
{
    return yp;
}

inline void QPointF::setX(qreal xpos)
{
    xp = xpos;
}

inline void QPointF::setY(qreal ypos)
{
    yp = ypos;
}

inline qreal &QPointF::rx()
{
    return xp;
}

inline qreal &QPointF::ry()
{
    return yp;
}

inline QPointF &QPointF::operator+=(const QPointF &p)
{
    xp+=p.xp;
    yp+=p.yp;
    return *this;
}

inline QPointF &QPointF::operator-=(const QPointF &p)
{
    xp-=p.xp; yp-=p.yp; return *this;
}

inline QPointF &QPointF::operator*=(qreal c)
{
    xp*=c; yp*=c; return *this;
}

inline bool operator==(const QPointF &p1, const QPointF &p2)
{
    return qFuzzyCompare(p1.xp, p2.xp) && qFuzzyCompare(p1.yp, p2.yp);
}

inline bool operator!=(const QPointF &p1, const QPointF &p2)
{
    return !qFuzzyCompare(p1.xp, p2.xp) || !qFuzzyCompare(p1.yp, p2.yp);
}

inline const QPointF operator+(const QPointF &p1, const QPointF &p2)
{
    return QPointF(p1.xp+p2.xp, p1.yp+p2.yp);
}

inline const QPointF operator-(const QPointF &p1, const QPointF &p2)
{
    return QPointF(p1.xp-p2.xp, p1.yp-p2.yp);
}

inline const QPointF operator*(const QPointF &p, qreal c)
{
    return QPointF(p.xp*c, p.yp*c);
}

inline const QPointF operator*(qreal c, const QPointF &p)
{
    return QPointF(p.xp*c, p.yp*c);
}

inline const QPointF operator-(const QPointF &p)
{
    return QPointF(-p.xp, -p.yp);
}

inline QPointF &QPointF::operator/=(qreal c)
{
    do {if(!(!qFuzzyCompare(c, 0)))qt_assert("!qFuzzyCompare(c, 0)","../../include/QtCore/../../src/corelib/tools/qpoint.h",316);} while (0);
    xp/=c;
    yp/=c;
    return *this;
}

inline const QPointF operator/(const QPointF &p, qreal c)
{
    do {if(!(!qFuzzyCompare(c, 0)))qt_assert("!qFuzzyCompare(c, 0)","../../include/QtCore/../../src/corelib/tools/qpoint.h",324);} while (0);
    return QPointF(p.xp/c, p.yp/c);
}

inline QPoint QPointF::toPoint() const
{
    return QPoint(qRound(xp), qRound(yp));
}


 QDebug operator<<(QDebug d, const QPointF &p);




#line 2 "../../include/QtCore/qpoint.h"
#line 27 "../../include/QtGui/../../src/gui/painting/qbrush.h"
#line 1 "../../include/QtCore/qvector.h"
#line 28 "../../include/QtGui/../../src/gui/painting/qbrush.h"
#line 1 "../../include/QtGui/qcolor.h"
#line 29 "../../include/QtGui/../../src/gui/painting/qbrush.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

struct QBrushData;
class QPixmap;
class QGradient;
class QVariant;

class  QBrush
{
public:
    QBrush();
    QBrush(Qt::BrushStyle bs);
    QBrush(const QColor &color, Qt::BrushStyle bs=Qt::SolidPattern);
    QBrush(Qt::GlobalColor color, Qt::BrushStyle bs=Qt::SolidPattern);

    QBrush(const QColor &color, const QPixmap &pixmap);
    QBrush(Qt::GlobalColor color, const QPixmap &pixmap);
    QBrush(const QPixmap &pixmap);

    QBrush(const QBrush &brush);

    QBrush(const QGradient &gradient);

    ~QBrush();
    QBrush &operator=(const QBrush &brush);
    operator QVariant() const;

    inline Qt::BrushStyle style() const;
    void setStyle(Qt::BrushStyle);

    QPixmap texture() const;
    void setTexture(const QPixmap &pixmap);

    inline const QColor &color() const;
    void setColor(const QColor &color);
    inline void setColor(Qt::GlobalColor color);

    const QGradient *gradient() const;

    bool isOpaque() const;

    bool operator==(const QBrush &b) const;
    inline bool operator!=(const QBrush &b) const { return !(operator==(b)); }


    inline  operator const QColor&() const;
     QPixmap *pixmap() const;
    inline  void setPixmap(const QPixmap &pixmap) { setTexture(pixmap); }


private:

    friend class QX11PaintEngine;

    friend class QPainter;
    void detach(Qt::BrushStyle newStyle);
    void init(const QColor &color, Qt::BrushStyle bs);
    QBrushData *d;
    void cleanUp(QBrushData *x);
};

inline void QBrush::setColor(Qt::GlobalColor acolor)
{ setColor(QColor(acolor)); }

template <> class QTypeInfo<QBrush> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QBrush)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QBrush"; } };



 


 QDataStream &operator<<(QDataStream &, const QBrush &);
 QDataStream &operator>>(QDataStream &, QBrush &);



 QDebug operator<<(QDebug, const QBrush &);


struct QBrushData
{
    QAtomic ref;
    Qt::BrushStyle style;
    QColor color;
};

inline Qt::BrushStyle QBrush::style() const { return d->style; }
inline const QColor &QBrush::color() const { return d->color; }


inline QBrush::operator const QColor&() const { return d->color; }





 
class QGradientPrivate;

typedef QPair<qreal, QColor> QGradientStop;
typedef QVector<QGradientStop> QGradientStops;

class  QGradient
{
public:
    enum Type {
        LinearGradient,
        RadialGradient,
        ConicalGradient,
        NoGradient
    };

    enum Spread {
        PadSpread,
        ReflectSpread,
        RepeatSpread
    };

    QGradient();

    Type type() const { return m_type; }

    inline void setSpread(Spread spread);
    Spread spread() const { return m_spread; }

    void setColorAt(qreal pos, const QColor &color);

    void setStops(const QGradientStops &stops);
    QGradientStops stops() const;

    bool operator==(const QGradient &gradient); 
    bool operator==(const QGradient &gradient) const;


private:
    friend class QLinearGradient;
    friend class QRadialGradient;
    friend class QConicalGradient;

    Type m_type;
    Spread m_spread;
    QGradientStops m_stops;
    union {
        struct {
            qreal x1, y1, x2, y2;
        } linear;
        struct {
            qreal cx, cy, fx, fy, radius;
        } radial;
        struct {
            qreal cx, cy, angle;
        } conical;
    } m_data;
    void *dummy;
};

inline void QGradient::setSpread(Spread aspread)
{ m_spread = aspread; }

class  QLinearGradient : public QGradient
{
public:
    QLinearGradient(const QPointF &start, const QPointF &finalStop);
    QLinearGradient(qreal xStart, qreal yStart, qreal xFinalStop, qreal yFinalStop);

    QPointF start() const;
    QPointF finalStop() const;
};


class  QRadialGradient : public QGradient
{
public:
    QRadialGradient(const QPointF &center, qreal radius, const QPointF &focalPoint = QPointF());
    QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx=0, qreal fy=0);

    QPointF center() const;
    QPointF focalPoint() const;
    qreal radius() const;
};


class  QConicalGradient : public QGradient
{
public:
    QConicalGradient(const QPointF &center, qreal startAngle);
    QConicalGradient(qreal cx, qreal cy, qreal startAngle);

    QPointF center() const;
    qreal angle() const;
};



#line 2 "../../include/QtGui/qbrush.h"
#line 32 "text/qtextformat.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QString;
class QVariant;
class QFont;

class QTextFormatCollection;
class QTextFormatPrivate;
class QTextBlockFormat;
class QTextCharFormat;
class QTextListFormat;
class QTextTableFormat;
class QTextFrameFormat;
class QTextImageFormat;
class QTextFormat;
class QTextObject;
class QTextCursor;
class QTextDocument;
class QTextLength;

 QDataStream &operator<<(QDataStream &, const QTextLength &);
 QDataStream &operator>>(QDataStream &, QTextLength &);

class  QTextLength
{
public:
    enum Type { VariableLength = 0, FixedLength, PercentageLength };

    inline QTextLength() : lengthType(VariableLength), fixedValueOrPercentage(0) {}

    inline explicit QTextLength(Type type, qreal value);

    inline Type type() const { return lengthType; }
    inline qreal value(qreal maximumLength) const
    {
        switch (lengthType) {
            case FixedLength: return fixedValueOrPercentage;
            case VariableLength: return maximumLength;
            case PercentageLength: return fixedValueOrPercentage * maximumLength / qreal(100);
        }
        return -1;
    }

    inline qreal rawValue() const { return fixedValueOrPercentage; }

    inline bool operator==(const QTextLength &other) const
    { return lengthType == other.lengthType
             && qFuzzyCompare(fixedValueOrPercentage, other.fixedValueOrPercentage); }
    inline bool operator!=(const QTextLength &other) const
    { return lengthType != other.lengthType
             || !qFuzzyCompare(fixedValueOrPercentage, other.fixedValueOrPercentage); }
    operator QVariant() const;

private:
    Type lengthType;
    qreal fixedValueOrPercentage;
    friend  QDataStream &operator<<(QDataStream &, const QTextLength &);
    friend  QDataStream &operator>>(QDataStream &, QTextLength &);
};

inline QTextLength::QTextLength(Type atype, qreal avalue)
    : lengthType(atype), fixedValueOrPercentage(avalue) {}

 QDataStream &operator<<(QDataStream &, const QTextFormat &);
 QDataStream &operator>>(QDataStream &, QTextFormat &);

class  QTextFormat
{
    public: static const QMetaObject staticMetaObject; private:
    
public:
    enum FormatType {
        InvalidFormat = -1,
        BlockFormat = 1,
        CharFormat = 2,
        ListFormat = 3,
        TableFormat = 4,
        FrameFormat = 5,

        UserFormat = 100
    };

    enum Property {
        ObjectIndex = 0x0,

        
        CssFloat = 0x0800,
        LayoutDirection = 0x0801,

        OutlinePen = 0x810,
        BackgroundBrush = 0x820,
        ForegroundBrush = 0x821,

        
        BlockAlignment = 0x1010,
        BlockTopMargin = 0x1030,
        BlockBottomMargin = 0x1031,
        BlockLeftMargin = 0x1032,
        BlockRightMargin = 0x1033,
        TextIndent = 0x1034,
        BlockIndent = 0x1040,
        BlockNonBreakableLines = 0x1050,
        BlockTrailingHorizontalRulerWidth = 0x1060,

        
        FontFamily = 0x2000,
        FontPointSize = 0x2001,
        FontSizeAdjustment = 0x2002,
        FontSizeIncrement = FontSizeAdjustment, 
        FontWeight = 0x2003,
        FontItalic = 0x2004,
        FontUnderline = 0x2005,
        FontOverline = 0x2006,
        FontStrikeOut = 0x2007,
        FontFixedPitch = 0x2008,
        FontPixelSize = 0x2009,

        TextUnderlineColor = 0x2010,
        TextVerticalAlignment = 0x2021,
        TextOutline = 0x2022,

        IsAnchor = 0x2030,
        AnchorHref = 0x2031,
        AnchorName = 0x2032,

        ObjectType = 0x2f00,

        
        ListStyle = 0x3000,
        ListIndent = 0x3001,

        
        FrameBorder = 0x4000,
        FrameMargin = 0x4001,
        FramePadding = 0x4002,
        FrameWidth = 0x4003,
        FrameHeight = 0x4004,
        TableColumns = 0x4100,
        TableColumnWidthConstraints = 0x4101,
        TableCellSpacing = 0x4102,
        TableCellPadding = 0x4103,

        
        TableCellRowSpan = 0x4810,
        TableCellColumnSpan = 0x4811,

        
        ImageName = 0x5000,
        ImageWidth = 0x5010,
        ImageHeight = 0x5011,

        
        UserProperty = 0x100000
    };

    enum ObjectTypes {
        NoObject,
        ImageObject,
        TableObject,

        UserObject = 0x1000
    };

    QTextFormat();

    explicit QTextFormat(int type);

    QTextFormat(const QTextFormat &rhs);
    QTextFormat &operator=(const QTextFormat &rhs);
    ~QTextFormat();

    void merge(const QTextFormat &other);

    inline bool isValid() const { return type() != InvalidFormat; }

    int type() const;

    int objectIndex() const;
    void setObjectIndex(int object);

    QVariant property(int propertyId) const;
    void setProperty(int propertyId, const QVariant &value);
    void clearProperty(int propertyId);
    bool hasProperty(int propertyId) const;

    bool boolProperty(int propertyId) const;
    int intProperty(int propertyId) const;
    qreal doubleProperty(int propertyId) const;
    QString stringProperty(int propertyId) const;
    QColor colorProperty(int propertyId) const;
    QPen penProperty(int propertyId) const;
    QBrush brushProperty(int propertyId) const;
    QTextLength lengthProperty(int propertyId) const;
    QVector<QTextLength> lengthVectorProperty(int propertyId) const;

    void setProperty(int propertyId, const QVector<QTextLength> &lengths);


    QMap<int, QVariant> properties() const;

    inline void setObjectType(int type);
    inline int objectType() const
    { return intProperty(ObjectType); }

    inline bool isCharFormat() const { return type() == CharFormat; }
    inline bool isBlockFormat() const { return type() == BlockFormat; }
    inline bool isListFormat() const { return type() == ListFormat; }
    inline bool isFrameFormat() const { return type() == FrameFormat; }
    inline bool isImageFormat() const { return type() == CharFormat && objectType() == ImageObject; }
    inline bool isTableFormat() const { return type() == FrameFormat && objectType() == TableObject; }

    QTextBlockFormat toBlockFormat() const;
    QTextCharFormat toCharFormat() const;
    QTextListFormat toListFormat() const;
    QTextTableFormat toTableFormat() const;
    QTextFrameFormat toFrameFormat() const;
    QTextImageFormat toImageFormat() const;

    bool operator==(const QTextFormat &rhs) const;
    inline bool operator!=(const QTextFormat &rhs) const { return !operator==(rhs); }
    operator QVariant() const;

    inline void setLayoutDirection(Qt::LayoutDirection direction)
        { setProperty(QTextFormat::LayoutDirection, direction); }
    inline Qt::LayoutDirection layoutDirection() const
        { return Qt::LayoutDirection(intProperty(QTextFormat::LayoutDirection)); }

    inline void setBackground(const QBrush &brush)
    { setProperty(BackgroundBrush, brush); }
    inline QBrush background() const
    { return brushProperty(BackgroundBrush); }
    inline void clearBackground()
    { clearProperty(BackgroundBrush); }

    inline void setForeground(const QBrush &brush)
    { setProperty(ForegroundBrush, brush); }
    inline QBrush foreground() const
    { return brushProperty(ForegroundBrush); }
    inline void clearForeground()
    { clearProperty(ForegroundBrush); }

private:
    QSharedDataPointer<QTextFormatPrivate> d;
    qint32 format_type;

    friend class QTextFormatCollection;
    friend class QTextCharFormat;
    friend  QDataStream &operator<<(QDataStream &, const QTextFormat &);
    friend  QDataStream &operator>>(QDataStream &, QTextFormat &);
};

inline void QTextFormat::setObjectType(int atype)
{ setProperty(ObjectType, atype); }

class  QTextCharFormat : public QTextFormat
{
public:
    enum VerticalAlignment { AlignNormal = 0, AlignSuperScript, AlignSubScript };

    QTextCharFormat();

    bool isValid() const { return isCharFormat(); }
    void setFont(const QFont &font);
    QFont font() const;

    inline void setFontFamily(const QString &family)
    { setProperty(FontFamily, family); }
    inline QString fontFamily() const
    { return stringProperty(FontFamily); }

    inline void setFontPointSize(qreal size)
    { setProperty(FontPointSize, size); }
    inline qreal fontPointSize() const
    { return doubleProperty(FontPointSize); }

    inline void setFontWeight(int weight)
    { if (weight == QFont::Normal) weight = 0; setProperty(FontWeight, weight); }
    inline int fontWeight() const
    { int weight = intProperty(FontWeight); if (weight == 0) weight = QFont::Normal; return weight; }
    inline void setFontItalic(bool italic)
    { setProperty(FontItalic, italic); }
    inline bool fontItalic() const
    { return boolProperty(FontItalic); }

    inline void setFontUnderline(bool underline)
    { setProperty(FontUnderline, underline); }
    inline bool fontUnderline() const
    { return boolProperty(FontUnderline); }

    inline void setFontOverline(bool overline)
    { setProperty(FontOverline, overline); }
    inline bool fontOverline() const
    { return boolProperty(FontOverline); }

    inline void setFontStrikeOut(bool strikeOut)
    { setProperty(FontStrikeOut, strikeOut); }
    inline bool fontStrikeOut() const
    { return boolProperty(FontStrikeOut); }

    inline void setUnderlineColor(const QColor &color)
    { setProperty(TextUnderlineColor, color); }
    inline QColor underlineColor() const
    { return colorProperty(TextUnderlineColor); }

    inline void setFontFixedPitch(bool fixedPitch)
    { setProperty(FontFixedPitch, fixedPitch); }
    inline bool fontFixedPitch() const
    { return boolProperty(FontFixedPitch); }

    inline void setVerticalAlignment(VerticalAlignment alignment)
    { setProperty(TextVerticalAlignment, alignment); }
    inline VerticalAlignment verticalAlignment() const
    { return static_cast<VerticalAlignment>(intProperty(TextVerticalAlignment)); }

    inline void setTextOutline(const QPen &pen)
    { setProperty(TextOutline, pen); }
    inline QPen textOutline() const
    { return penProperty(TextOutline); }

    inline void setAnchor(bool anchor)
    { setProperty(IsAnchor, anchor); }
    inline bool isAnchor() const
    { return boolProperty(IsAnchor); }

    inline void setAnchorHref(const QString &value)
    { setProperty(AnchorHref, value); }
    inline QString anchorHref() const
    { return stringProperty(AnchorHref); }

    inline void setAnchorName(const QString &name)
    { setProperty(AnchorName, name); }
    inline QString anchorName() const
    { return stringProperty(AnchorName); }

    inline void setTableCellRowSpan(int tableCellRowSpan);
    inline int tableCellRowSpan() const
    { int s = intProperty(TableCellRowSpan); if (s == 0) s = 1; return s; }
    inline void setTableCellColumnSpan(int tableCellColumnSpan);
    inline int tableCellColumnSpan() const
    { int s = intProperty(TableCellColumnSpan); if (s == 0) s = 1; return s; }
};

inline void QTextCharFormat::setTableCellRowSpan(int atableCellRowSpan)
{
    if (atableCellRowSpan == 1)
	atableCellRowSpan = 0;
    setProperty(TableCellRowSpan, atableCellRowSpan);
}

inline void QTextCharFormat::setTableCellColumnSpan(int atableCellColumnSpan)
{
    if (atableCellColumnSpan == 1)
	atableCellColumnSpan = 0;
    setProperty(TableCellColumnSpan, atableCellColumnSpan);
}

class  QTextBlockFormat : public QTextFormat
{
public:
    QTextBlockFormat();

    bool isValid() const { return isBlockFormat(); }

    inline void setAlignment(Qt::Alignment alignment);
    inline Qt::Alignment alignment() const
    { return QFlag(intProperty(BlockAlignment)); }

    inline void setTopMargin(qreal margin)
    { setProperty(BlockTopMargin, margin); }
    inline qreal topMargin() const
    { return doubleProperty(BlockTopMargin); }

    inline void setBottomMargin(qreal margin)
    { setProperty(BlockBottomMargin, margin); }
    inline qreal bottomMargin() const
    { return doubleProperty(BlockBottomMargin); }

    inline void setLeftMargin(qreal margin)
    { setProperty(BlockLeftMargin, margin); }
    inline qreal leftMargin() const
    { return doubleProperty(BlockLeftMargin); }

    inline void setRightMargin(qreal margin)
    { setProperty(BlockRightMargin, margin); }
    inline qreal rightMargin() const
    { return doubleProperty(BlockRightMargin); }

    inline void setTextIndent(qreal margin)
    { setProperty(TextIndent, margin); }
    inline qreal textIndent() const
    { return doubleProperty(TextIndent); }

    inline void setIndent(int indent);
    inline int indent() const
    { return intProperty(BlockIndent); }

    inline void setNonBreakableLines(bool b)
    { setProperty(BlockNonBreakableLines, b); }
    inline bool nonBreakableLines() const
    { return boolProperty(BlockNonBreakableLines); }
};

inline void QTextBlockFormat::setAlignment(Qt::Alignment aalignment)
{ setProperty(BlockAlignment, int(aalignment)); }

inline void QTextBlockFormat::setIndent(int aindent)
{ setProperty(BlockIndent, aindent); }

class  QTextListFormat : public QTextFormat
{
public:
    QTextListFormat();

    bool isValid() const { return isListFormat(); }

    enum Style {
        ListDisc = -1,
        ListCircle = -2,
        ListSquare = -3,
        ListDecimal = -4,
        ListLowerAlpha = -5,
        ListUpperAlpha = -6,
        ListStyleUndefined = 0
    };

    inline void setStyle(Style style);
    inline Style style() const
    { return static_cast<Style>(intProperty(ListStyle)); }

    inline void setIndent(int indent);
    inline int indent() const
    { return intProperty(ListIndent); }

};

inline void QTextListFormat::setStyle(Style astyle)
{ setProperty(ListStyle, astyle); }

inline void QTextListFormat::setIndent(int aindent)
{ setProperty(ListIndent, aindent); }

class  QTextImageFormat : public QTextCharFormat
{
public:
    QTextImageFormat();

    bool isValid() const { return isImageFormat(); }

    inline void setName(const QString &name);
    inline QString name() const
    { return stringProperty(ImageName); }

    inline void setWidth(qreal width);
    inline qreal width() const
    { return doubleProperty(ImageWidth); }

    inline void setHeight(qreal height);
    inline qreal height() const
    { return doubleProperty(ImageHeight); }
};

inline void QTextImageFormat::setName(const QString &aname)
{ setProperty(ImageName, aname); }

inline void QTextImageFormat::setWidth(qreal awidth)
{ setProperty(ImageWidth, awidth); }

inline void QTextImageFormat::setHeight(qreal aheight)
{ setProperty(ImageHeight, aheight); }

class  QTextFrameFormat : public QTextFormat
{
public:
    QTextFrameFormat();

    bool isValid() const { return isFrameFormat(); }

    enum Position {
        InFlow,
        FloatLeft,
        FloatRight
        

    };

    inline void setPosition(Position f)
    { setProperty(CssFloat, f); }
    inline Position position() const
    { return static_cast<Position>(intProperty(CssFloat)); }

    inline void setBorder(qreal border);
    inline qreal border() const
    { return doubleProperty(FrameBorder); }

    inline void setMargin(qreal margin);
    inline qreal margin() const
    { return doubleProperty(FrameMargin); }

    inline void setPadding(qreal padding);
    inline qreal padding() const
    { return doubleProperty(FramePadding); }

    inline void setWidth(qreal width);
    inline void setWidth(const QTextLength &length)
    { setProperty(FrameWidth, length); }
    inline QTextLength width() const
    { return lengthProperty(FrameWidth); }

    inline void setHeight(qreal height);
    inline void setHeight(const QTextLength &height);
    inline QTextLength height() const
    { return lengthProperty(FrameHeight); }
};

inline void QTextFrameFormat::setBorder(qreal aborder)
{ setProperty(FrameBorder, aborder); }

inline void QTextFrameFormat::setMargin(qreal amargin)
{ setProperty(FrameMargin, amargin); }

inline void QTextFrameFormat::setPadding(qreal apadding)
{ setProperty(FramePadding, apadding); }

inline void QTextFrameFormat::setWidth(qreal awidth)
{ setProperty(FrameWidth, QTextLength(QTextLength::FixedLength, awidth)); }

inline void QTextFrameFormat::setHeight(qreal aheight)
{ setProperty(FrameHeight, QTextLength(QTextLength::FixedLength, aheight)); }
inline void QTextFrameFormat::setHeight(const QTextLength &aheight)
{ setProperty(FrameHeight, aheight); }

class  QTextTableFormat : public QTextFrameFormat
{
public:
    QTextTableFormat();

    inline bool isValid() const { return isTableFormat(); }

    inline int columns() const
    { int cols = intProperty(TableColumns); if (cols == 0) cols = 1; return cols; }
    inline void setColumns(int columns);

    inline void setColumnWidthConstraints(const QVector<QTextLength> &constraints)
    { setProperty(TableColumnWidthConstraints, constraints); }

    inline QVector<QTextLength> columnWidthConstraints() const
    { return lengthVectorProperty(TableColumnWidthConstraints); }

    inline void clearColumnWidthConstraints()
    { clearProperty(TableColumnWidthConstraints); }

    inline qreal cellSpacing() const
    { return doubleProperty(TableCellSpacing); }
    inline void setCellSpacing(qreal spacing)
    { setProperty(TableCellSpacing, spacing); }

    inline qreal cellPadding() const
    { return doubleProperty(TableCellPadding); }
    inline void setCellPadding(qreal padding);

    inline void setAlignment(Qt::Alignment alignment);
    inline Qt::Alignment alignment() const
    { return QFlag(intProperty(BlockAlignment)); }
};

inline void QTextTableFormat::setColumns(int acolumns)
{
    if (acolumns == 1)
        acolumns = 0;
    setProperty(TableColumns, acolumns);
}

inline void QTextTableFormat::setCellPadding(qreal apadding)
{ setProperty(TableCellPadding, apadding); }

inline void QTextTableFormat::setAlignment(Qt::Alignment aalignment)
{ setProperty(BlockAlignment, int(aalignment)); }



#line 24 "text/qtextengine.cpp"
#line 1 "text/qtextformat_p.h"



















 















#line 1 "../../include/QtGui/qtextformat.h"
#line 37 "text/qtextformat_p.h"
#line 1 "../../include/QtCore/qvector.h"
#line 38 "text/qtextformat_p.h"
#line 1 "../../include/QtCore/qset.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qset.h"



















 




#line 1 "../../include/QtCore/qhash.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qset.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

template <class T>
class QSet
{
    typedef QHash<T, QHashDummyValue> Hash;

public:
    inline QSet() {}
    inline QSet(const QSet<T> &other) : q_hash(other.q_hash) {}

    inline QSet<T> &operator=(const QSet<T> &other)
        { q_hash = other.q_hash; return *this; }

    inline bool operator==(const QSet<T> &other) const
        { return q_hash == other.q_hash; }
    inline bool operator!=(const QSet<T> &other) const
        { return q_hash != other.q_hash; }

    inline int size() const { return q_hash.size(); }

    inline bool isEmpty() const { return q_hash.isEmpty(); }

    inline int capacity() const { return q_hash.capacity(); }
    inline void reserve(int size);
    inline void squeeze() { q_hash.squeeze(); }

    inline void detach() { q_hash.detach(); }
    inline bool isDetached() const { return q_hash.isDetached(); }

    inline void clear() { q_hash.clear(); }

    inline bool remove(const T &value) { return q_hash.remove(value) != 0; }

    inline bool contains(const T &value) const { return q_hash.contains(value); }

    class const_iterator
    {
        typedef QHash<T, QHashDummyValue> Hash;
        typename Hash::const_iterator i;

    public:
        typedef std::bidirectional_iterator_tag iterator_category;
        typedef ptrdiff_t difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        inline const_iterator() {}
        inline const_iterator(typename Hash::const_iterator o) : i(o) {}
        inline const_iterator(const const_iterator &o) : i(o.i) {}
        inline const_iterator &operator=(const const_iterator &o) { i = o.i; return *this; }
        inline const T &operator*() const { return i.key(); }
        inline const T *operator->() const { return &i.key(); }
        inline bool operator==(const const_iterator &o) const { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
        inline const_iterator &operator++() { ++i; return *this; }
        inline const_iterator operator++(int) { const_iterator r = *this; ++i; return r; }
        inline const_iterator &operator--() { --i; return *this; }
        inline const_iterator operator--(int) { const_iterator r = *this; --i; return r; }
        inline const_iterator operator+(int j) const { return i + j; }
        inline const_iterator operator-(int j) const { return i - j; }
        inline const_iterator &operator+=(int j) { i += j; return *this; }
        inline const_iterator &operator-=(int j) { i -= j; return *this; }
    };

    
    inline const_iterator begin() const { return q_hash.begin(); }
    inline const_iterator constBegin() const { return q_hash.constBegin(); }
    inline const_iterator end() const { return q_hash.end(); }
    inline const_iterator constEnd() const { return q_hash.constEnd(); }

    
    typedef const_iterator ConstIterator;
    inline int count() const { return q_hash.count(); }
    inline const_iterator insert(const T &value)
        { return static_cast<typename Hash::const_iterator>(q_hash.insert(value,
                                                                          QHashDummyValue())); }
    QSet<T> &unite(const QSet<T> &other);
    QSet<T> &intersect(const QSet<T> &other);
    QSet<T> &subtract(const QSet<T> &other);

    
    inline bool empty() const { return isEmpty(); }

    
    inline QSet<T> &operator<<(const T &value) { insert(value); return *this; }
    inline QSet<T> &operator|=(const QSet<T> &other) { unite(other); return *this; }
    inline QSet<T> &operator|=(const T &value) { insert(value); return *this; }
    inline QSet<T> &operator&=(const QSet<T> &other) { intersect(other); return *this; }
    inline QSet<T> &operator&=(const T &value)
        { QSet<T> result; if (contains(value)) result.insert(value); return (*this = result); }
    inline QSet<T> &operator+=(const QSet<T> &other) { unite(other); return *this; }
    inline QSet<T> &operator+=(const T &value) { insert(value); return *this; }
    inline QSet<T> &operator-=(const QSet<T> &other) { subtract(other); return *this; }
    inline QSet<T> &operator-=(const T &value) { remove(value); return *this; }
    inline QSet<T> operator|(const QSet<T> &other)
        { QSet<T> result = *this; result |= other; return result; }
    inline QSet<T> operator&(const QSet<T> &other)
        { QSet<T> result = *this; result &= other; return result; }
    inline QSet<T> operator+(const QSet<T> &other)
        { QSet<T> result = *this; result += other; return result; }
    inline QSet<T> operator-(const QSet<T> &other)
        { QSet<T> result = *this; result -= other; return result; }

    QList<T> toList() const;
    inline QList<T> values() const { return toList(); }

    static QSet<T> fromList(const QList<T> &list);

private:
    Hash q_hash;
};

template <class T>
inline void QSet<T>::reserve(int asize) { q_hash.reserve(asize); }

template <class T>
inline QSet<T> &QSet<T>::unite(const QSet<T> &other)
{
    QSet<T> copy(other);
    typename QSet<T>::const_iterator i = copy.constEnd();
    while (i != copy.constBegin()) {
        --i;
        insert(*i);
    }
    return *this;
}

template <class T>
inline QSet<T> &QSet<T>::intersect(const QSet<T> &other)
{
    QSet<T> copy1(*this);
    QSet<T> copy2(other);
    typename QSet<T>::const_iterator i = copy1.constEnd();
    while (i != copy1.constBegin()) {
        --i;
        if (!copy2.contains(*i))
            remove(*i);
    }
    return *this;
}

template <class T>
inline QSet<T> &QSet<T>::subtract(const QSet<T> &other)
{
    QSet<T> copy1(*this);
    QSet<T> copy2(other);
    typename QSet<T>::const_iterator i = copy1.constEnd();
    while (i != copy1.constBegin()) {
        --i;
        if (copy2.contains(*i))
            remove(*i);
    }
    return *this;
}

template <typename T>
 QList<T> QSet<T>::toList() const
{
    QList<T> result;
    typename QSet<T>::const_iterator i = constBegin();
    while (i != constEnd()) {
        result.append(*i);
        ++i;
    }
    return result;
}

template <typename T>
 QSet<T> QList<T>::toSet() const
{
    QSet<T> result;
    result.reserve(size());
    for (int i = 0; i < size(); ++i)
        result.insert(at(i));
    return result;
}

template <typename T>
QSet<T> QSet<T>::fromList(const QList<T> &list)
{
    return list.toSet();
}

template <typename T>
QList<T> QList<T>::fromSet(const QSet<T> &set)
{
    return set.toList();
}

template <class T> class QSetIterator { typedef typename QSet<T> ::const_iterator const_iterator; QSet<T> c; const_iterator i; public: inline QSetIterator(const QSet<T> &container) : c(container), i(c . constBegin()) {} inline QSetIterator &operator=(const QSet<T> &container) { c = container; i = c . constBegin(); return *this; } inline void toFront() { i = c . constBegin(); } inline void toBack() { i = c . constEnd(); } inline bool hasNext() const { return i != c . constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c . constBegin(); } inline const T &previous() { return * --i; } inline const T &peekPrevious() const { const_iterator p = i; return * --p; } inline bool findNext(const T &t) { while (i != c . constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c . constBegin()) if (*(--i) == t) return true; return false; } };



#line 2 "../../include/QtCore/qset.h"
#line 39 "text/qtextformat_p.h"

class QTextFormatCollection
{
public:
    QTextFormatCollection() {}
    ~QTextFormatCollection();

    QTextFormatCollection(const QTextFormatCollection &rhs);
    QTextFormatCollection &operator=(const QTextFormatCollection &rhs);

    QTextFormat objectFormat(int objectIndex) const;
    void setObjectFormat(int objectIndex, const QTextFormat &format);

    int objectFormatIndex(int objectIndex) const;
    void setObjectFormatIndex(int objectIndex, int formatIndex);

    int createObjectIndex(const QTextFormat &f);

    int indexForFormat(const QTextFormat &f);
    bool hasFormatCached(const QTextFormat &format) const;

    QTextFormat format(int idx) const;
    inline QTextBlockFormat blockFormat(int index) const
    { return format(index).toBlockFormat(); }
    inline QTextCharFormat charFormat(int index) const
    { return format(index).toCharFormat(); }
    inline QTextListFormat listFormat(int index) const
    { return format(index).toListFormat(); }
    inline QTextTableFormat tableFormat(int index) const
    { return format(index).toTableFormat(); }
    inline QTextImageFormat imageFormat(int index) const
    { return format(index).toImageFormat(); }

    inline int numFormats() const { return formats.count(); }

    typedef QVector<QTextFormat> FormatVector;

    FormatVector formats;
    QVector<qint32> objFormats;
    QSet<uint> hashes;

    inline QFont defaultFont() const { return defaultFnt; }
    void setDefaultFont(const QFont &f);

private:
    QFont defaultFnt;
};

#line 25 "text/qtextengine.cpp"
#line 1 "text/qtextengine_p.h"



















 















#line 1 "../../include/QtCore/qglobal.h"
#line 37 "text/qtextengine_p.h"
#line 1 "../../include/QtCore/qstring.h"
#line 38 "text/qtextengine_p.h"
#line 1 "../../include/QtCore/qnamespace.h"
#line 39 "text/qtextengine_p.h"
#line 1 "../../include/QtGui/qtextlayout.h"
#line 1 "../../include/QtGui/../../src/gui/text/qtextlayout.h"



















 



#line 1 "../../include/QtCore/qstring.h"
#line 25 "../../include/QtGui/../../src/gui/text/qtextlayout.h"
#line 1 "../../include/QtCore/qnamespace.h"
#line 26 "../../include/QtGui/../../src/gui/text/qtextlayout.h"
#line 1 "../../include/QtCore/qrect.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qrect.h"



















 




#line 1 "../../include/QtCore/qsize.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qsize.h"



















 




#line 1 "../../include/QtCore/qnamespace.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qsize.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class  QSize
{
public:
    QSize();
    QSize(int w, int h);

    bool isNull() const;
    bool isEmpty() const;
    bool isValid() const;

    int width() const;
    int height() const;
    void setWidth(int w);
    void setHeight(int h);
    void transpose();

    void scale(int w, int h, Qt::AspectRatioMode mode);
    void scale(const QSize &s, Qt::AspectRatioMode mode);

    QSize expandedTo(const QSize &) const;
    QSize boundedTo(const QSize &) const;

    int &rwidth();
    int &rheight();

    QSize &operator+=(const QSize &);
    QSize &operator-=(const QSize &);
    QSize &operator*=(qreal c);
    QSize &operator/=(qreal c);

    friend inline bool operator==(const QSize &, const QSize &);
    friend inline bool operator!=(const QSize &, const QSize &);
    friend inline const QSize operator+(const QSize &, const QSize &);
    friend inline const QSize operator-(const QSize &, const QSize &);
    friend inline const QSize operator*(const QSize &, qreal);
    friend inline const QSize operator*(qreal, const QSize &);
    friend inline const QSize operator/(const QSize &, qreal);

private:
    int wd;
    int ht;
};
template <> class QTypeInfo<QSize> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSize)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSize"; } };



 

 QDataStream &operator<<(QDataStream &, const QSize &);
 QDataStream &operator>>(QDataStream &, QSize &);




 

inline QSize::QSize()
{ wd = ht = -1; }

inline QSize::QSize(int w, int h)
{ wd = w; ht = h; }

inline bool QSize::isNull() const
{ return wd==0 && ht==0; }

inline bool QSize::isEmpty() const
{ return wd<1 || ht<1; }

inline bool QSize::isValid() const
{ return wd>=0 && ht>=0; }

inline int QSize::width() const
{ return wd; }

inline int QSize::height() const
{ return ht; }

inline void QSize::setWidth(int w)
{ wd = w; }

inline void QSize::setHeight(int h)
{ ht = h; }

inline void QSize::scale(int w, int h, Qt::AspectRatioMode mode)
{ scale(QSize(w, h), mode); }

inline int &QSize::rwidth()
{ return wd; }

inline int &QSize::rheight()
{ return ht; }

inline QSize &QSize::operator+=(const QSize &s)
{ wd+=s.wd; ht+=s.ht; return *this; }

inline QSize &QSize::operator-=(const QSize &s)
{ wd-=s.wd; ht-=s.ht; return *this; }

inline QSize &QSize::operator*=(qreal c)
{ wd = qRound(wd*c); ht = qRound(ht*c); return *this; }

inline bool operator==(const QSize &s1, const QSize &s2)
{ return s1.wd == s2.wd && s1.ht == s2.ht; }

inline bool operator!=(const QSize &s1, const QSize &s2)
{ return s1.wd != s2.wd || s1.ht != s2.ht; }

inline const QSize operator+(const QSize & s1, const QSize & s2)
{ return QSize(s1.wd+s2.wd, s1.ht+s2.ht); }

inline const QSize operator-(const QSize &s1, const QSize &s2)
{ return QSize(s1.wd-s2.wd, s1.ht-s2.ht); }

inline const QSize operator*(const QSize &s, qreal c)
{ return QSize(qRound(s.wd*c), qRound(s.ht*c)); }

inline const QSize operator*(qreal c, const QSize &s)
{ return QSize(qRound(s.wd*c), qRound(s.ht*c)); }

inline QSize &QSize::operator/=(qreal c)
{
    do {if(!(!qFuzzyCompare(c, 0)))qt_assert("!qFuzzyCompare(c, 0)","../../include/QtCore/../../src/corelib/tools/qsize.h",152);} while (0);
    wd = qRound(wd/c); ht = qRound(ht/c);
    return *this;
}

inline const QSize operator/(const QSize &s, qreal c)
{
    do {if(!(!qFuzzyCompare(c, 0)))qt_assert("!qFuzzyCompare(c, 0)","../../include/QtCore/../../src/corelib/tools/qsize.h",159);} while (0);
    return QSize(qRound(s.wd/c), qRound(s.ht/c));
}

inline QSize QSize::expandedTo(const QSize & otherSize) const
{
    return QSize(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht));
}

inline QSize QSize::boundedTo(const QSize & otherSize) const
{
    return QSize(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht));
}


 QDebug operator<<(QDebug, const QSize &);



class  QSizeF
{
public:
    QSizeF();
    QSizeF(const QSize &sz);
    QSizeF(qreal w, qreal h);

    bool isNull() const;
    bool isEmpty() const;
    bool isValid() const;

    qreal width() const;
    qreal height() const;
    void setWidth(qreal w);
    void setHeight(qreal h);
    void transpose();

    void scale(qreal w, qreal h, Qt::AspectRatioMode mode);
    void scale(const QSizeF &s, Qt::AspectRatioMode mode);

    QSizeF expandedTo(const QSizeF &) const;
    QSizeF boundedTo(const QSizeF &) const;

    qreal &rwidth();
    qreal &rheight();

    QSizeF &operator+=(const QSizeF &);
    QSizeF &operator-=(const QSizeF &);
    QSizeF &operator*=(qreal c);
    QSizeF &operator/=(qreal c);

    friend inline bool operator==(const QSizeF &, const QSizeF &);
    friend inline bool operator!=(const QSizeF &, const QSizeF &);
    friend inline const QSizeF operator+(const QSizeF &, const QSizeF &);
    friend inline const QSizeF operator-(const QSizeF &, const QSizeF &);
    friend inline const QSizeF operator*(const QSizeF &, qreal);
    friend inline const QSizeF operator*(qreal, const QSizeF &);
    friend inline const QSizeF operator/(const QSizeF &, qreal);

    inline QSize toSize() const;

private:
    qreal wd;
    qreal ht;
};
template <> class QTypeInfo<QSizeF> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSizeF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSizeF"; } };




 

 QDataStream &operator<<(QDataStream &, const QSizeF &);
 QDataStream &operator>>(QDataStream &, QSizeF &);




 

inline QSizeF::QSizeF()
{ wd = ht = -1.; }

inline QSizeF::QSizeF(const QSize &sz)
    : wd(sz.width()), ht(sz.height())
{
}

inline QSizeF::QSizeF(qreal w, qreal h)
{ wd = w; ht = h; }

inline bool QSizeF::isNull() const
{ return qIsNull(wd) && qIsNull(ht); }

inline bool QSizeF::isEmpty() const
{ return wd <= 0. || ht <= 0.; }

inline bool QSizeF::isValid() const
{ return wd >= 0. && ht >= 0.; }

inline qreal QSizeF::width() const
{ return wd; }

inline qreal QSizeF::height() const
{ return ht; }

inline void QSizeF::setWidth(qreal w)
{ wd = w; }

inline void QSizeF::setHeight(qreal h)
{ ht = h; }

inline void QSizeF::scale(qreal w, qreal h, Qt::AspectRatioMode mode)
{ scale(QSizeF(w, h), mode); }

inline qreal &QSizeF::rwidth()
{ return wd; }

inline qreal &QSizeF::rheight()
{ return ht; }

inline QSizeF &QSizeF::operator+=(const QSizeF &s)
{ wd += s.wd; ht += s.ht; return *this; }

inline QSizeF &QSizeF::operator-=(const QSizeF &s)
{ wd -= s.wd; ht -= s.ht; return *this; }

inline QSizeF &QSizeF::operator*=(qreal c)
{ wd *= c; ht *= c; return *this; }

inline bool operator==(const QSizeF &s1, const QSizeF &s2)
{ return qFuzzyCompare(s1.wd, s2.wd) && qFuzzyCompare(s1.ht, s2.ht); }

inline bool operator!=(const QSizeF &s1, const QSizeF &s2)
{ return !qFuzzyCompare(s1.wd, s2.wd) || !qFuzzyCompare(s1.ht, s2.ht); }

inline const QSizeF operator+(const QSizeF & s1, const QSizeF & s2)
{ return QSizeF(s1.wd+s2.wd, s1.ht+s2.ht); }

inline const QSizeF operator-(const QSizeF &s1, const QSizeF &s2)
{ return QSizeF(s1.wd-s2.wd, s1.ht-s2.ht); }

inline const QSizeF operator*(const QSizeF &s, qreal c)
{ return QSizeF(s.wd*c, s.ht*c); }

inline const QSizeF operator*(qreal c, const QSizeF &s)
{ return QSizeF(s.wd*c, s.ht*c); }

inline QSizeF &QSizeF::operator/=(qreal c)
{
    do {if(!(!qFuzzyCompare(c, 0)))qt_assert("!qFuzzyCompare(c, 0)","../../include/QtCore/../../src/corelib/tools/qsize.h",308);} while (0);
    wd = wd/c; ht = ht/c;
    return *this;
}

inline const QSizeF operator/(const QSizeF &s, qreal c)
{
    do {if(!(!qFuzzyCompare(c, 0)))qt_assert("!qFuzzyCompare(c, 0)","../../include/QtCore/../../src/corelib/tools/qsize.h",315);} while (0);
    return QSizeF(s.wd/c, s.ht/c);
}

inline QSizeF QSizeF::expandedTo(const QSizeF & otherSize) const
{
    return QSizeF(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht));
}

inline QSizeF QSizeF::boundedTo(const QSizeF & otherSize) const
{
    return QSizeF(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht));
}

inline QSize QSizeF::toSize() const
{
    return QSize(qRound(wd), qRound(ht));
}


 QDebug operator<<(QDebug, const QSizeF &);




#line 2 "../../include/QtCore/qsize.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qrect.h"
#line 1 "../../include/QtCore/qpoint.h"
#line 27 "../../include/QtCore/../../src/corelib/tools/qrect.h"







typedef QtValidLicenseForCoreModule QtCoreModule;

class  QRect
{
public:
    QRect() { x1 = y1 = 0; x2 = y2 = -1; }
    QRect(const QPoint &topleft, const QPoint &bottomright);
    QRect(const QPoint &topleft, const QSize &size);
    QRect(int left, int top, int width, int height);

    bool isNull() const;
    bool isEmpty() const;
    bool isValid() const;

    int left() const;
    int top() const;
    int right() const;
    int bottom() const;
    QRect normalized() const;


     int &rLeft() { return x1; }
     int &rTop() { return y1; }
     int &rRight() { return x2; }
     int &rBottom() { return y2; }

     QRect normalize() const { return normalized(); }


    int x() const;
    int y() const;
    void setLeft(int pos);
    void setTop(int pos);
    void setRight(int pos);
    void setBottom(int pos);
    void setX(int x);
    void setY(int y);

    void setTopLeft(const QPoint &p);
    void setBottomRight(const QPoint &p);
    void setTopRight(const QPoint &p);
    void setBottomLeft(const QPoint &p);

    QPoint topLeft() const;
    QPoint bottomRight() const;
    QPoint topRight() const;
    QPoint bottomLeft() const;
    QPoint center() const;

    void moveLeft(int pos);
    void moveTop(int pos);
    void moveRight(int pos);
    void moveBottom(int pos);
    void moveTopLeft(const QPoint &p);
    void moveBottomRight(const QPoint &p);
    void moveTopRight(const QPoint &p);
    void moveBottomLeft(const QPoint &p);
    void moveCenter(const QPoint &p);

    inline void translate(int dx, int dy);
    inline void translate(const QPoint &p);
    inline QRect translated(int dx, int dy) const;
    inline QRect translated(const QPoint &p) const;

    void moveTo(int x, int t);
    void moveTo(const QPoint &p);


     void moveBy(int dx, int dy) { translate(dx, dy); }
     void moveBy(const QPoint &p) { translate(p); }


    void setRect(int x, int y, int w, int h);
    inline void getRect(int *x, int *y, int *w, int *h) const;

    void setCoords(int x1, int y1, int x2, int y2);

     void addCoords(int x1, int y1, int x2, int y2);

    inline void getCoords(int *x1, int *y1, int *x2, int *y2) const;

    inline void adjust(int x1, int y1, int x2, int y2);
    inline QRect adjusted(int x1, int y1, int x2, int y2) const;

    QSize size() const;
    int width() const;
    int height() const;
    void setWidth(int w);
    void setHeight(int h);
    void setSize(const QSize &s);

    QRect operator|(const QRect &r) const;
    QRect operator&(const QRect &r) const;
    QRect& operator|=(const QRect &r);
    QRect& operator&=(const QRect &r);

    bool contains(const QPoint &p, bool proper=false) const;
    bool contains(int x, int y) const; 
    bool contains(int x, int y, bool proper) const;
    bool contains(const QRect &r, bool proper=false) const;
    QRect unite(const QRect &r) const;
    QRect intersect(const QRect &r) const;
    bool intersects(const QRect &r) const;

    friend  inline bool operator==(const QRect &, const QRect &);
    friend  inline bool operator!=(const QRect &, const QRect &);


    inline  void rect(int *x, int *y, int *w, int *h) const { getRect(x, y, w, h); }
    inline  void coords(int *ax1, int *ay1, int *ax2, int *ay2) const
    { getCoords(ax1, ay1, ax2, ay2); }


private:

    friend void qt_setCoords(QRect *r, int xp1, int yp1, int xp2, int yp2);
#line 157 "../../include/QtCore/../../src/corelib/tools/qrect.h"
    int x1;
    int y1;
    int x2;
    int y2;


};
template <> class QTypeInfo<QRect> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRect)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRect"; } };

 inline bool operator==(const QRect &, const QRect &);
 inline bool operator!=(const QRect &, const QRect &);




 

 QDataStream &operator<<(QDataStream &, const QRect &);
 QDataStream &operator>>(QDataStream &, QRect &);




 

inline QRect::QRect(int aleft, int atop, int awidth, int aheight)
{
    x1 = aleft;
    y1 = atop;
    x2 = (aleft + awidth - 1);
    y2 = (atop + aheight - 1);
}

inline QRect::QRect(const QPoint &atopLeft, const QPoint &abottomRight)
{
    x1 = atopLeft.x();
    y1 = atopLeft.y();
    x2 = abottomRight.x();
    y2 = abottomRight.y();
}

inline QRect::QRect(const QPoint &atopLeft, const QSize &asize)
{
    x1 = atopLeft.x();
    y1 = atopLeft.y();
    x2 = (x1+asize.width() - 1);
    y2 = (y1+asize.height() - 1);
}

inline bool QRect::isNull() const
{ return x2 == x1 - 1 && y2 == y1 - 1; }

inline bool QRect::isEmpty() const
{ return x1 > x2 || y1 > y2; }

inline bool QRect::isValid() const
{ return x1 <= x2 && y1 <= y2; }

inline int QRect::left() const
{ return x1; }

inline int QRect::top() const
{ return y1; }

inline int QRect::right() const
{ return x2; }

inline int QRect::bottom() const
{ return y2; }

inline int QRect::x() const
{ return x1; }

inline int QRect::y() const
{ return y1; }

inline void QRect::setLeft(int pos)
{ x1 = pos; }

inline void QRect::setTop(int pos)
{ y1 = pos; }

inline void QRect::setRight(int pos)
{ x2 = pos; }

inline void QRect::setBottom(int pos)
{ y2 = pos; }

inline void QRect::setTopLeft(const QPoint &p)
{ x1 = p.x(); y1 = p.y(); }

inline void QRect::setBottomRight(const QPoint &p)
{ x2 = p.x(); y2 = p.y(); }

inline void QRect::setTopRight(const QPoint &p)
{ x2 = p.x(); y1 = p.y(); }

inline void QRect::setBottomLeft(const QPoint &p)
{ x1 = p.x(); y2 = p.y(); }

inline void QRect::setX(int ax)
{ x1 = ax; }

inline void QRect::setY(int ay)
{ y1 = ay; }

inline QPoint QRect::topLeft() const
{ return QPoint(x1, y1); }

inline QPoint QRect::bottomRight() const
{ return QPoint(x2, y2); }

inline QPoint QRect::topRight() const
{ return QPoint(x2, y1); }

inline QPoint QRect::bottomLeft() const
{ return QPoint(x1, y2); }

inline QPoint QRect::center() const
{ return QPoint((x1+x2)/2, (y1+y2)/2); }

inline int QRect::width() const
{ return  x2 - x1 + 1; }

inline int QRect::height() const
{ return  y2 - y1 + 1; }

inline QSize QRect::size() const
{ return QSize(width(), height()); }

inline void QRect::translate(int dx, int dy)
{
    x1 += dx;
    y1 += dy;
    x2 += dx;
    y2 += dy;
}

inline void QRect::translate(const QPoint &p)
{
    x1 += p.x();
    y1 += p.y();
    x2 += p.x();
    y2 += p.y();
}

inline QRect QRect::translated(int dx, int dy) const
{ return QRect(QPoint(x1 + dx, y1 + dy), QPoint(x2 + dx, y2 + dy)); }

inline QRect QRect::translated(const QPoint &p) const
{ return QRect(QPoint(x1 + p.x(), y1 + p.y()), QPoint(x2 + p.x(), y2 + p.y())); }

inline void QRect::moveTo(int ax, int ay)
{
    x2 += ax - x1;
    y2 += ay - y1;
    x1 = ax;
    y1 = ay;
}

inline void QRect::moveTo(const QPoint &p)
{
    x2 += p.x() - x1;
    y2 += p.y() - y1;
    x1 = p.x();
    y1 = p.y();
}

inline void QRect::moveLeft(int pos)
{ x2 += (pos - x1); x1 = pos; }

inline void QRect::moveTop(int pos)
{ y2 += (pos - y1); y1 = pos; }

inline void QRect::moveRight(int pos)
{
    x1 += (pos - x2);
    x2 = pos;
}

inline void QRect::moveBottom(int pos)
{
    y1 += (pos - y2);
    y2 = pos;
}

inline void QRect::moveTopLeft(const QPoint &p)
{
    moveLeft(p.x());
    moveTop(p.y());
}

inline void QRect::moveBottomRight(const QPoint &p)
{
    moveRight(p.x());
    moveBottom(p.y());
}

inline void QRect::moveTopRight(const QPoint &p)
{
    moveRight(p.x());
    moveTop(p.y());
}

inline void QRect::moveBottomLeft(const QPoint &p)
{
    moveLeft(p.x());
    moveBottom(p.y());
}

inline void QRect::getRect(int *ax, int *ay, int *aw, int *ah) const
{
    *ax = x1;
    *ay = y1;
    *aw = x2 - x1 + 1;
    *ah = y2 - y1 + 1;
}

inline void QRect::setRect(int ax, int ay, int aw, int ah)
{
    x1 = ax;
    y1 = ay;
    x2 = (ax + aw - 1);
    y2 = (ay + ah - 1);
}

inline void QRect::getCoords(int *xp1, int *yp1, int *xp2, int *yp2) const
{
    *xp1 = x1;
    *yp1 = y1;
    *xp2 = x2;
    *yp2 = y2;
}

inline void QRect::setCoords(int xp1, int yp1, int xp2, int yp2)
{
    x1 = xp1;
    y1 = yp1;
    x2 = xp2;
    y2 = yp2;
}


inline void QRect::addCoords(int dx1, int dy1, int dx2, int dy2)
{
    adjust(dx1, dy1, dx2, dy2);
}


inline QRect QRect::adjusted(int xp1, int yp1, int xp2, int yp2) const
{ return QRect(QPoint(x1 + xp1, y1 + yp1), QPoint(x2 + xp2, y2 + yp2)); }

inline void QRect::adjust(int dx1, int dy1, int dx2, int dy2)
{
    x1 += dx1;
    y1 += dy1;
    x2 += dx2;
    y2 += dy2;
}

inline void QRect::setWidth(int w)
{ x2 = (x1 + w - 1); }

inline void QRect::setHeight(int h)
{ y2 = (y1 + h - 1); }

inline void QRect::setSize(const QSize &s)
{
    x2 = (s.width()  + x1 - 1);
    y2 = (s.height() + y1 - 1);
}

inline bool QRect::contains(int ax, int ay, bool aproper) const
{
    return contains(QPoint(ax, ay), aproper);
}

inline bool QRect::contains(int ax, int ay) const
{
    return contains(QPoint(ax, ay), false);
}

inline QRect& QRect::operator|=(const QRect &r)
{
    *this = *this | r;
    return *this;
}

inline QRect& QRect::operator&=(const QRect &r)
{
    *this = *this & r;
    return *this;
}

inline QRect QRect::intersect(const QRect &r) const
{
    return *this & r;
}
inline QRect QRect::unite(const QRect &r) const
{
    return *this | r;
}

inline bool operator==(const QRect &r1, const QRect &r2)
{
    return r1.x1==r2.x1 && r1.x2==r2.x2 && r1.y1==r2.y1 && r1.y2==r2.y2;
}

inline bool operator!=(const QRect &r1, const QRect &r2)
{
    return r1.x1!=r2.x1 || r1.x2!=r2.x2 || r1.y1!=r2.y1 || r1.y2!=r2.y2;
}


 QDebug operator<<(QDebug, const QRect &);



class  QRectF
{
public:
    QRectF() { xp = yp = 0.; w = h = 0.; }
    QRectF(const QPointF &topleft, const QSizeF &size);
    QRectF(qreal left, qreal top, qreal width, qreal height);
    QRectF(const QRect &rect);

    bool isNull() const;
    bool isEmpty() const;
    bool isValid() const;
    QRectF normalized() const;

    inline qreal left() const { return xp; }
    inline qreal top() const { return yp; }
    inline qreal right() const { return xp + w; }
    inline qreal bottom() const { return yp + h; }

    inline qreal x() const;
    inline qreal y() const;
    inline void setLeft(qreal pos);
    inline void setTop(qreal pos);
    inline void setRight(qreal pos);
    inline void setBottom(qreal pos);
    inline void setX(qreal pos) { setLeft(pos); }
    inline void setY(qreal pos) { setTop(pos); }

    inline QPointF topLeft() const { return QPointF(xp, yp); }
    inline QPointF bottomRight() const { return QPointF(xp+w, yp+h); }
    inline QPointF topRight() const { return QPointF(xp+w, yp); }
    inline QPointF bottomLeft() const { return QPointF(xp, yp+h); }
    inline QPointF center() const;

    void setTopLeft(const QPointF &p);
    void setBottomRight(const QPointF &p);
    void setTopRight(const QPointF &p);
    void setBottomLeft(const QPointF &p);

    void moveLeft(qreal pos);
    void moveTop(qreal pos);
    void moveRight(qreal pos);
    void moveBottom(qreal pos);
    void moveTopLeft(const QPointF &p);
    void moveBottomRight(const QPointF &p);
    void moveTopRight(const QPointF &p);
    void moveBottomLeft(const QPointF &p);
    void moveCenter(const QPointF &p);

    void translate(qreal dx, qreal dy);
    void translate(const QPointF &p);

    QRectF translated(qreal dx, qreal dy) const;
    QRectF translated(const QPointF &p) const;

    void moveTo(qreal x, qreal t);
    void moveTo(const QPointF &p);

    void setRect(qreal x, qreal y, qreal w, qreal h);
    void getRect(qreal *x, qreal *y, qreal *w, qreal *h) const;

    void setCoords(qreal x1, qreal y1, qreal x2, qreal y2);
    void getCoords(qreal *x1, qreal *y1, qreal *x2, qreal *y2) const;

    inline void adjust(qreal x1, qreal y1, qreal x2, qreal y2);
    inline QRectF adjusted(qreal x1, qreal y1, qreal x2, qreal y2) const;

    QSizeF size() const;
    qreal width() const;
    qreal height() const;
    void setWidth(qreal w);
    void setHeight(qreal h);
    void setSize(const QSizeF &s);

    QRectF operator|(const QRectF &r) const;
    QRectF operator&(const QRectF &r) const;
    QRectF& operator|=(const QRectF &r);
    QRectF& operator&=(const QRectF &r);

    bool contains(const QPointF &p) const;
    bool contains(qreal x, qreal y) const;
    bool contains(const QRectF &r) const;
    QRectF unite(const QRectF &r) const;
    QRectF intersect(const QRectF &r) const;
    bool intersects(const QRectF &r) const;

    friend  inline bool operator==(const QRectF &, const QRectF &);
    friend  inline bool operator!=(const QRectF &, const QRectF &);

    QRect toRect() const;

private:
    qreal xp;
    qreal yp;
    qreal w;
    qreal h;
};
template <> class QTypeInfo<QRectF> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRectF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRectF"; } };

 inline bool operator==(const QRectF &, const QRectF &);
 inline bool operator!=(const QRectF &, const QRectF &);




 

 QDataStream &operator<<(QDataStream &, const QRectF &);
 QDataStream &operator>>(QDataStream &, QRectF &);




 

inline QRectF::QRectF(qreal aleft, qreal atop, qreal awidth, qreal aheight)
    : xp(aleft), yp(atop), w(awidth), h(aheight)
{
}

inline QRectF::QRectF(const QPointF &atopLeft, const QSizeF &asize)
{
    xp = atopLeft.x();
    yp = atopLeft.y();
    w = asize.width();
    h = asize.height();
}

inline QRectF::QRectF(const QRect &r)
    : xp(r.x()), yp(r.y()), w(r.width()), h(r.height())
{
}

inline bool QRectF::isNull() const
{ return qIsNull(w) && qIsNull(h); }

inline bool QRectF::isEmpty() const
{ return w <= 0. || h <= 0.; }

inline bool QRectF::isValid() const
{ return w > 0. && h > 0.; }

inline qreal QRectF::x() const
{ return xp; }

inline qreal QRectF::y() const
{ return yp; }

inline void QRectF::setLeft(qreal pos) { qreal diff = pos - xp; xp += diff; w -= diff; }

inline void QRectF::setRight(qreal pos) { w = pos - xp; }

inline void QRectF::setTop(qreal pos) { qreal diff = pos - yp; yp += diff; h -= diff; }

inline void QRectF::setBottom(qreal pos) { h = pos - yp; }

inline void QRectF::setTopLeft(const QPointF &p) { setLeft(p.x()); setTop(p.y()); }

inline void QRectF::setTopRight(const QPointF &p) { setRight(p.x()); setTop(p.y()); }

inline void QRectF::setBottomLeft(const QPointF &p) { setLeft(p.x()); setBottom(p.y()); }

inline void QRectF::setBottomRight(const QPointF &p) { setRight(p.x()); setBottom(p.y()); }

inline QPointF QRectF::center() const
{ return QPointF(xp + w/2, yp + h/2); }

inline void QRectF::moveLeft(qreal pos) { xp = pos; }

inline void QRectF::moveTop(qreal pos) { yp = pos; }

inline void QRectF::moveRight(qreal pos) { xp = pos - w; }

inline void QRectF::moveBottom(qreal pos) { yp = pos - h; }

inline void QRectF::moveTopLeft(const QPointF &p) { moveLeft(p.x()); moveTop(p.y()); }

inline void QRectF::moveTopRight(const QPointF &p) { moveRight(p.x()); moveTop(p.y()); }

inline void QRectF::moveBottomLeft(const QPointF &p) { moveLeft(p.x()); moveBottom(p.y()); }

inline void QRectF::moveBottomRight(const QPointF &p) { moveRight(p.x()); moveBottom(p.y()); }

inline void QRectF::moveCenter(const QPointF &p) { xp = p.x() - w/2; yp = p.y() - h/2; }

inline qreal QRectF::width() const
{ return w; }

inline qreal QRectF::height() const
{ return h; }

inline QSizeF QRectF::size() const
{ return QSizeF(w, h); }

inline void QRectF::translate(qreal dx, qreal dy)
{
    xp += dx;
    yp += dy;
}

inline void QRectF::translate(const QPointF &p)
{
    xp += p.x();
    yp += p.y();
}

inline void QRectF::moveTo(qreal ax, qreal ay)
{
    xp = ax;
    yp = ay;
}

inline void QRectF::moveTo(const QPointF &p)
{
    xp = p.x();
    yp = p.y();
}

inline QRectF QRectF::translated(qreal dx, qreal dy) const
{ return QRectF(xp + dx, yp + dy, w, h); }

inline QRectF QRectF::translated(const QPointF &p) const
{ return QRectF(xp + p.x(), yp + p.y(), w, h); }

inline void QRectF::getRect(qreal *ax, qreal *ay, qreal *aaw, qreal *aah) const
{
    *ax = this->xp;
    *ay = this->yp;
    *aaw = this->w;
    *aah = this->h;
}

inline void QRectF::setRect(qreal ax, qreal ay, qreal aaw, qreal aah)
{
    this->xp = ax;
    this->yp = ay;
    this->w = aaw;
    this->h = aah;
}

inline void QRectF::getCoords(qreal *xp1, qreal *yp1, qreal *xp2, qreal *yp2) const
{
    *xp1 = xp;
    *yp1 = yp;
    *xp2 = xp + w;
    *yp2 = yp + h;
}

inline void QRectF::setCoords(qreal xp1, qreal yp1, qreal xp2, qreal yp2)
{
    xp = xp1;
    yp = yp1;
    w = xp2 - xp1;
    h = yp2 - yp1;
}

inline void QRectF::adjust(qreal xp1, qreal yp1, qreal xp2, qreal yp2)
{ xp += xp1; yp += yp1; w += xp2 - xp1; h += yp2 - yp1; }

inline QRectF QRectF::adjusted(qreal xp1, qreal yp1, qreal xp2, qreal yp2) const
{ return QRectF(xp + xp1, yp + yp1, w + xp2 - xp1, h + yp2 - yp1); }

inline void QRectF::setWidth(qreal aw)
{ this->w = aw; }

inline void QRectF::setHeight(qreal ah)
{ this->h = ah; }

inline void QRectF::setSize(const QSizeF &s)
{
    w = s.width();
    h = s.height();
}

inline bool QRectF::contains(qreal ax, qreal ay) const
{
    return contains(QPointF(ax, ay));
}

inline QRectF& QRectF::operator|=(const QRectF &r)
{
    *this = *this | r;
    return *this;
}

inline QRectF& QRectF::operator&=(const QRectF &r)
{
    *this = *this & r;
    return *this;
}

inline QRectF QRectF::intersect(const QRectF &r) const
{
    return *this & r;
}
inline QRectF QRectF::unite(const QRectF &r) const
{
    return *this | r;
}

inline bool operator==(const QRectF &r1, const QRectF &r2)
{
    return qFuzzyCompare(r1.xp, r2.xp) && qFuzzyCompare(r1.yp, r2.yp)
           && qFuzzyCompare(r1.w, r2.w) && qFuzzyCompare(r1.h, r2.h);
}

inline bool operator!=(const QRectF &r1, const QRectF &r2)
{
    return !qFuzzyCompare(r1.xp, r2.xp) || !qFuzzyCompare(r1.yp, r2.yp)
           || !qFuzzyCompare(r1.w, r2.w) || !qFuzzyCompare(r1.h, r2.h);
}

inline QRect QRectF::toRect() const
{
    return QRect(qRound(xp), qRound(yp), qRound(w), qRound(h));
}


 QDebug operator<<(QDebug, const QRectF &);




#line 2 "../../include/QtCore/qrect.h"
#line 27 "../../include/QtGui/../../src/gui/text/qtextlayout.h"
#line 1 "../../include/QtCore/qvector.h"
#line 28 "../../include/QtGui/../../src/gui/text/qtextlayout.h"
#line 1 "../../include/QtGui/qcolor.h"
#line 29 "../../include/QtGui/../../src/gui/text/qtextlayout.h"
#line 1 "../../include/QtCore/qobject.h"
#line 30 "../../include/QtGui/../../src/gui/text/qtextlayout.h"
#line 1 "../../include/QtGui/qevent.h"
#line 1 "../../include/QtGui/../../src/gui/kernel/qevent.h"



















 




#line 1 "../../include/QtGui/qwindowdefs.h"
#line 26 "../../include/QtGui/../../src/gui/kernel/qevent.h"
#line 1 "../../include/QtCore/qobject.h"
#line 27 "../../include/QtGui/../../src/gui/kernel/qevent.h"
#line 1 "../../include/QtGui/qregion.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qregion.h"



















 




#line 1 "../../include/QtCore/qatomic.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qregion.h"
#line 1 "../../include/QtCore/qrect.h"
#line 27 "../../include/QtGui/../../src/gui/painting/qregion.h"
#line 1 "../../include/QtGui/qwindowdefs.h"
#line 28 "../../include/QtGui/../../src/gui/painting/qregion.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

template <class T> class QVector;
class QVariant;


struct QRegionPrivate;


class QBitmap;

class  QRegion
{
public:
    enum RegionType { Rectangle, Ellipse };

    QRegion();
    QRegion(int x, int y, int w, int h, RegionType t = Rectangle);
    QRegion(const QRect &r, RegionType t = Rectangle);
    QRegion(const QPolygon &pa, Qt::FillRule fillRule = Qt::OddEvenFill);

    explicit QRegion(const QPolygon &pa, bool winding);

    QRegion(const QRegion &region);
    QRegion(const QBitmap &bitmap);
    ~QRegion();
    QRegion &operator=(const QRegion &);


    inline  bool isNull() const { return isEmpty(); }

    bool isEmpty() const;

    bool contains(const QPoint &p) const;
    bool contains(const QRect &r) const;

    void translate(int dx, int dy);
    inline void translate(const QPoint &p) { translate(p.x(), p.y()); }
    QRegion translated(int dx, int dy) const;
    inline QRegion translated(const QPoint &p) const { return translated(p.x(), p.y()); }

    QRegion unite(const QRegion &r) const;
    QRegion intersect(const QRegion &r) const;
    QRegion subtract(const QRegion &r) const;
    QRegion eor(const QRegion &r) const;

    QRect boundingRect() const;
    QVector<QRect> rects() const;
    void setRects(const QRect *rect, int num);

    const QRegion operator|(const QRegion &r) const;
    const QRegion operator+(const QRegion &r) const;
    const QRegion operator&(const QRegion &r) const;
    const QRegion operator-(const QRegion &r) const;
    const QRegion operator^(const QRegion &r) const;
    QRegion& operator|=(const QRegion &r);
    QRegion& operator+=(const QRegion &r);
    QRegion& operator&=(const QRegion &r);
    QRegion& operator-=(const QRegion &r);
    QRegion& operator^=(const QRegion &r);

    bool operator==(const QRegion &r) const;
    inline bool operator!=(const QRegion &r) const { return !(operator==(r)); }
    operator QVariant() const;






    inline Region handle() const { if(!d->rgn) updateX11Region(); return d->rgn; }
#line 109 "../../include/QtGui/../../src/gui/painting/qregion.h"


    friend  QDataStream &operator<<(QDataStream &, const QRegion &);
    friend  QDataStream &operator>>(QDataStream &, QRegion &);

private:
    QRegion copy() const;   
    void detach();



    void updateX11Region() const;
    void *clipRectangles(int &num) const;
    friend void *qt_getClipRects(const QRegion &r, int &num);



    void exec(const QByteArray &ba, int ver = 0);
    struct QRegionData {
        QBasicAtomic ref;



        Region rgn;
        void *xrectangles;




        QRegionPrivate *qt_rgn;

    };



    struct QRegionData *d;
    static struct QRegionData shared_empty;
    static void cleanUp(QRegionData *x);
};



 


 QDataStream &operator<<(QDataStream &, const QRegion &);
 QDataStream &operator>>(QDataStream &, QRegion &);



 QDebug operator<<(QDebug, const QRegion &);




#line 2 "../../include/QtGui/qregion.h"
#line 28 "../../include/QtGui/../../src/gui/kernel/qevent.h"
#line 1 "../../include/QtCore/qnamespace.h"
#line 29 "../../include/QtGui/../../src/gui/kernel/qevent.h"
#line 1 "../../include/QtCore/qstring.h"
#line 30 "../../include/QtGui/../../src/gui/kernel/qevent.h"
#line 1 "../../include/QtGui/qkeysequence.h"
#line 1 "../../include/QtGui/../../src/gui/kernel/qkeysequence.h"



















 




#line 1 "../../include/QtCore/qnamespace.h"
#line 26 "../../include/QtGui/../../src/gui/kernel/qkeysequence.h"
#line 1 "../../include/QtCore/qstring.h"
#line 27 "../../include/QtGui/../../src/gui/kernel/qkeysequence.h"



typedef QtValidLicenseForGuiModule QtGuiModule;





 

class QKeySequence;
 QDataStream &operator<<(QDataStream &in, const QKeySequence &ks);
 QDataStream &operator>>(QDataStream &out, QKeySequence &ks);


class QVariant;
class QKeySequencePrivate;

class  QKeySequence
{
public:
    QKeySequence();
    QKeySequence(const QString &key);
    QKeySequence(int k1, int k2 = 0, int k3 = 0, int k4 = 0);
    QKeySequence(const QKeySequence &ks);
    ~QKeySequence();

    uint count() const;
    bool isEmpty() const;

    enum SequenceMatch {
        NoMatch,
        PartialMatch,
        ExactMatch

        , Identical = ExactMatch

    };

    enum SequenceFormat {
        NativeText,
        PortableText
    };

    QString toString(SequenceFormat format = PortableText) const;
    static QKeySequence fromString(const QString &str, SequenceFormat format = PortableText);

    SequenceMatch matches(const QKeySequence &seq) const;
    static QKeySequence mnemonic(const QString &text);

    
    operator QString() const;
    operator QVariant() const;
    operator int() const;
    int operator[](uint i) const;
    QKeySequence &operator=(const QKeySequence &other);
    bool operator==(const QKeySequence &other) const;
    inline bool operator!= (const QKeySequence &other) const
    { return !(*this == other); }
    bool operator< (const QKeySequence &ks) const;
    inline bool operator> (const QKeySequence &other) const
    { return other < *this; }
    inline bool operator<= (const QKeySequence &other) const
    { return !(other < *this); }
    inline bool operator>= (const QKeySequence &other) const
    { return !(*this < other); }

    bool isDetached() const;
private:
    static int decodeString(const QString &ks);
    static QString encodeString(int key);
    int assign(const QString &str);
    void setKey(int key, int index);

    QKeySequencePrivate *d;

    friend  QDataStream &operator<<(QDataStream &in, const QKeySequence &ks);
    friend  QDataStream &operator>>(QDataStream &in, QKeySequence &ks);
    friend class Q3AccelManager;
    friend class QShortcutMap;
    friend class QShortcut;
};
template <> class QTypeInfo<QKeySequence> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QKeySequence)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QKeySequence"; } };
template <> inline bool qIsDetached<QKeySequence>(QKeySequence &t) { return t . isDetached(); }


 QDebug operator<<(QDebug, const QKeySequence &);


#line 127 "../../include/QtGui/../../src/gui/kernel/qkeysequence.h"



#line 2 "../../include/QtGui/qkeysequence.h"
#line 31 "../../include/QtGui/../../src/gui/kernel/qevent.h"
#line 1 "../../include/QtCore/qcoreevent.h"
#line 1 "../../include/QtCore/../../src/corelib/kernel/qcoreevent.h"



















 




#line 1 "../../include/QtCore/qnamespace.h"
#line 26 "../../include/QtCore/../../src/corelib/kernel/qcoreevent.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class QEventPrivate;
class  QEvent           
{
    
public:
    enum Type {
        




 
        None = 0,                               
        Timer = 1,                              
        MouseButtonPress = 2,                   
        MouseButtonRelease = 3,                 
        MouseButtonDblClick = 4,                
        MouseMove = 5,                          
        KeyPress = 6,                           
        KeyRelease = 7,                         
        FocusIn = 8,                            
        FocusOut = 9,                           
        Enter = 10,                             
        Leave = 11,                             
        Paint = 12,                             
        Move = 13,                              
        Resize = 14,                            
        Create = 15,                            
        Destroy = 16,                           
        Show = 17,                              
        Hide = 18,                              
        Close = 19,                             
        Quit = 20,                              
        ParentChange = 21,                      
        ParentAboutToChange = 131,              

        Reparent = ParentChange,

        ThreadChange = 22,                      
        WindowActivate = 24,                    
        WindowDeactivate = 25,                  
        ShowToParent = 26,                      
        HideToParent = 27,                      
        Wheel = 31,                             
        WindowTitleChange = 33,                 
        WindowIconChange = 34,                  
        ApplicationWindowIconChange = 35,       
        ApplicationFontChange = 36,             
        ApplicationLayoutDirectionChange = 37,  
        ApplicationPaletteChange = 38,          
        PaletteChange = 39,                     
        Clipboard = 40,                         
        Speech = 42,                            
        MetaCall =  43,                         
        SockAct = 50,                           
        WinEventAct = 132,                      
        DeferredDelete = 52,                    
        DragEnter = 60,                         
        DragMove = 61,                          
        DragLeave = 62,                         
        Drop = 63,                              
        DragResponse = 64,                      
        ChildAdded = 68,                        
        ChildPolished = 69,                     

        ChildInserted = 70,                     
        LayoutHint = 72,                        

        ChildRemoved = 71,                      
        ShowWindowRequest = 73,                 
        PolishRequest = 74,                     
        Polish = 75,                            
        LayoutRequest = 76,                     
        UpdateRequest = 77,                     
        UpdateLater = 78,                       

        EmbeddingControl = 79,                  
        ActivateControl = 80,                   
        DeactivateControl = 81,                 
        ContextMenu = 82,                       
        InputMethod = 83,                       
        AccessibilityPrepare = 86,              
        TabletMove = 87,                        
        LocaleChange = 88,                      
        LanguageChange = 89,                    
        LayoutDirectionChange = 90,             
        Style = 91,                             
        TabletPress = 92,                       
        TabletRelease = 93,                     
        OkRequest = 94,                         
        HelpRequest = 95,                       

        IconDrag = 96,                          

        FontChange = 97,                        
        EnabledChange = 98,                     
        ActivationChange = 99,                  
        StyleChange = 100,                      
        IconTextChange = 101,                   
        ModifiedChange = 102,                   
        MouseTrackingChange = 109,              

        WindowBlocked = 103,                    
        WindowUnblocked = 104,                  
        WindowStateChange = 105,

        ToolTip = 110,
        WhatsThis = 111,
        StatusTip = 112,

        ActionChanged = 113,
        ActionAdded = 114,
        ActionRemoved = 115,

        FileOpen = 116,                         

        Shortcut = 117,                         
        ShortcutOverride = 51,                  


        Accel = 30,                             
        AccelAvailable = 32,                    
        AccelOverride = ShortcutOverride,       


        WhatsThisClicked = 118,


        CaptionChange = WindowTitleChange,
        IconChange = WindowIconChange,

        ToolBarChange = 120,                    

        ApplicationActivated = 121,             
        ApplicationDeactivated = 122,           

        QueryWhatsThis = 123,                   
        EnterWhatsThisMode = 124,
        LeaveWhatsThisMode = 125,

        ZOrderChange = 126,                     

        HoverEnter = 127,                       
        HoverLeave = 128,                       
        HoverMove = 129,                        

        AccessibilityHelp = 119,                
        AccessibilityDescription = 130,         

        





        AcceptDropsChange = 152,

        MenubarUpdated = 153,                    
                                                 

        ZeroTimerEvent = 154,                   

        User = 1000,                            
        MaxUser = 65535                         
    };

    QEvent(Type type);
    virtual ~QEvent();
    inline Type type() const { return static_cast<Type>(t); }
    inline bool spontaneous() const { return spont; }

    inline void setAccepted(bool accepted) { m_accept = accepted; }
    inline bool isAccepted() const { return m_accept; }

    inline void accept() { m_accept = true; }
    inline void ignore() { m_accept = false; }

protected:
    QEventPrivate *d;
    ushort t;

private:
    ushort posted : 1;
    ushort spont : 1;
    ushort m_accept : 1;
    ushort reserved : 13;

    friend class QCoreApplication;
    friend class QCoreApplicationPrivate;
    friend class QThreadData;
    friend class QApplication;
    friend class QApplicationPrivate;
    friend class Q3AccelManager;
    friend class QShortcutMap;
    friend class QETWidget;
};

class  QTimerEvent : public QEvent
{
public:
    QTimerEvent( int timerId );
    ~QTimerEvent();
    int timerId() const { return id; }
protected:
    int id;
};

class QObject;

class  QChildEvent : public QEvent
{
public:
    QChildEvent( Type type, QObject *child );
    ~QChildEvent();
    QObject *child() const { return c; }
    bool added() const { return type() == ChildAdded; }

     bool inserted() const { return type() == ChildInserted; }

    bool polished() const { return type() == ChildPolished; }
    bool removed() const { return type() == ChildRemoved; }
protected:
    QObject *c;
};


class  QCustomEvent : public QEvent
{
public:
    explicit QCustomEvent(int type, void *data = 0);
    ~QCustomEvent();
     void *data()  const { return d; }
     void setData(void* data) { d = reinterpret_cast<QEventPrivate *>(data); }
};




#line 2 "../../include/QtCore/qcoreevent.h"
#line 32 "../../include/QtGui/../../src/gui/kernel/qevent.h"
#line 1 "../../include/QtGui/qmime.h"
#line 1 "../../include/QtGui/../../src/gui/kernel/qmime.h"



















 




#line 1 "../../include/QtCore/qmimedata.h"
#line 1 "../../include/QtCore/../../src/corelib/kernel/qmimedata.h"



















 




#line 1 "../../include/QtCore/qvariant.h"
#line 26 "../../include/QtCore/../../src/corelib/kernel/qmimedata.h"
#line 1 "../../include/QtCore/qobject.h"
#line 27 "../../include/QtCore/../../src/corelib/kernel/qmimedata.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class QUrl;
class QMimeDataPrivate;

class  QMimeData : public QObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:
public:
    QMimeData();
    ~QMimeData();

    QList<QUrl> urls() const;
    void setUrls(const QList<QUrl> &urls);
    bool hasUrls() const;

    QString text() const;
    void setText(const QString &text);
    bool hasText() const;

    QString html() const;
    void setHtml(const QString &html);
    bool hasHtml() const;

    QVariant imageData() const;
    void setImageData(const QVariant &image);
    bool hasImage() const;

    QVariant colorData() const;
    void setColorData(const QVariant &color);
    bool hasColor() const;

    QByteArray data(const QString &mimetype) const;
    void setData(const QString &mimetype, const QByteArray &data);

    virtual bool hasFormat(const QString &mimetype) const;
    virtual QStringList formats() const;

    void clear();
protected:
    virtual QVariant retrieveData(const QString &mimetype,
                                      QVariant::Type preferredType) const;
private:
    QMimeData(const QMimeData &); QMimeData &operator=(const QMimeData &);
    inline QMimeDataPrivate* d_func() { return reinterpret_cast<QMimeDataPrivate * >(d_ptr); } inline const QMimeDataPrivate* d_func() const { return reinterpret_cast<const QMimeDataPrivate * >(d_ptr); } friend class QMimeDataPrivate;
};



#line 2 "../../include/QtCore/qmimedata.h"
#line 26 "../../include/QtGui/../../src/gui/kernel/qmime.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class  QMimeSource
{
public:
    virtual ~QMimeSource();
    virtual const char* format(int n = 0) const = 0;
    virtual bool provides(const char*) const;
    virtual QByteArray encodedData(const char*) const = 0;
};


#line 117 "../../include/QtGui/../../src/gui/kernel/qmime.h"



#line 2 "../../include/QtGui/qmime.h"
#line 33 "../../include/QtGui/../../src/gui/kernel/qevent.h"
#line 1 "../../include/QtGui/qdrag.h"
#line 1 "../../include/QtGui/../../src/gui/kernel/qdrag.h"



















 




#line 1 "../../include/QtCore/qobject.h"
#line 26 "../../include/QtGui/../../src/gui/kernel/qdrag.h"



typedef QtValidLicenseForGuiModule QtGuiModule;


class QMimeData;
class QDragPrivate;
class QWidget;
class QPixmap;
class QPoint;
class QDragManager;

class  QDrag : public QObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:
    inline QDragPrivate* d_func() { return reinterpret_cast<QDragPrivate * >(d_ptr); } inline const QDragPrivate* d_func() const { return reinterpret_cast<const QDragPrivate * >(d_ptr); } friend class QDragPrivate;
public:
    explicit QDrag(QWidget *dragSource);
    ~QDrag();

    void setMimeData(QMimeData *data);
    QMimeData *mimeData() const;

    void setPixmap(const QPixmap &);
    QPixmap pixmap() const;

    void setHotSpot(const QPoint &hotspot);
    QPoint hotSpot() const;

    QWidget *source() const;
    QWidget *target() const;

    Qt::DropAction start(Qt::DropActions supportedActions = Qt::CopyAction);

    void setDragCursor(const QPixmap &cursor, Qt::DropAction action);

protected:
    void actionChanged(Qt::DropAction action);
    void targetChanged(QWidget *newTarget);

private:



    friend class QDragManager;
    QDrag(const QDrag &); QDrag &operator=(const QDrag &);
};





#line 2 "../../include/QtGui/qdrag.h"
#line 34 "../../include/QtGui/../../src/gui/kernel/qevent.h"
#line 1 "../../include/QtCore/qvariant.h"
#line 35 "../../include/QtGui/../../src/gui/kernel/qevent.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QAction;

class  QInputEvent : public QEvent
{
public:
    QInputEvent(Type type, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
    ~QInputEvent();
    inline Qt::KeyboardModifiers modifiers() const { return modState; }
protected:
    Qt::KeyboardModifiers modState;
};


class  QMouseEvent : public QInputEvent
{
public:
    QMouseEvent(Type type, const QPoint &pos, Qt::MouseButton button,
                Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);
    QMouseEvent(Type type, const QPoint &pos, const QPoint &globalPos,
                Qt::MouseButton button, Qt::MouseButtons buttons,
                Qt::KeyboardModifiers modifiers);
    ~QMouseEvent();

    inline const QPoint &pos() const { return p; }
    inline const QPoint &globalPos() const { return g; }
    inline int x() const { return p.x(); }
    inline int y() const { return p.y(); }
    inline int globalX() const { return g.x(); }
    inline int globalY() const { return g.y(); }
    inline Qt::MouseButton button() const { return b; }
    inline Qt::MouseButtons buttons() const { return mouseState; }


    explicit QMouseEvent(Type type, const QPoint &pos, Qt::ButtonState button, int state);
    explicit QMouseEvent(Type type, const QPoint &pos, const QPoint &globalPos,
                                      Qt::ButtonState button, int state);
    inline  Qt::ButtonState state() const
    { return Qt::ButtonState((mouseState^b)|int(modifiers())); }
    inline  Qt::ButtonState stateAfter() const
    { return Qt::ButtonState(int(mouseState)|int(modifiers())); }

protected:
    QPoint p, g;
    Qt::MouseButton b;
    Qt::MouseButtons mouseState;
};

class  QHoverEvent : public QEvent
{
public:
    QHoverEvent(Type type, const QPoint &pos, const QPoint &oldPos);
    ~QHoverEvent();

    inline const QPoint &pos() const { return p; }
    inline const QPoint &oldPos() const { return op; }

protected:
    QPoint p, op;
};


class  QWheelEvent : public QInputEvent
{
public:
    QWheelEvent(const QPoint &pos, int delta,
                Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
                Qt::Orientation orient = Qt::Vertical);
    QWheelEvent(const QPoint &pos, const QPoint& globalPos, int delta,
                Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
                Qt::Orientation orient = Qt::Vertical);
    ~QWheelEvent();

    inline int delta() const { return d; }
    inline const QPoint &pos() const { return p; }
    inline const QPoint &globalPos()   const { return g; }
    inline int x() const { return p.x(); }
    inline int y() const { return p.y(); }
    inline int globalX() const { return g.x(); }
    inline int globalY() const { return g.y(); }

    inline Qt::MouseButtons buttons() const { return mouseState; }
    Qt::Orientation orientation() const { return o; }


    explicit QWheelEvent(const QPoint &pos, int delta, int state,
                                      Qt::Orientation orient = Qt::Vertical);
    explicit QWheelEvent(const QPoint &pos, const QPoint& globalPos, int delta, int state,
                                      Qt::Orientation orient = Qt::Vertical);
    inline  Qt::ButtonState state() const
    { return static_cast<Qt::ButtonState>(int(buttons())|int(modifiers())); }

protected:
    QPoint p;
    QPoint g;
    int d;
    Qt::MouseButtons mouseState;
    Qt::Orientation o;
};


class  QTabletEvent : public QInputEvent
{
public:
    enum TabletDevice { NoDevice, Puck, Stylus, Airbrush, FourDMouse,
                        XFreeEraser  , RotationStylus };
    enum PointerType { UnknownPointer, Pen, Cursor, Eraser };
    QTabletEvent(Type t, const QPoint &pos, const QPoint &globalPos, const QPointF &hiResGlobalPos,
                 int device, int pointerType, qreal pressure, int xTilt, int yTilt,
                 qreal tangentialPressure, qreal rotation, int z,
                 Qt::KeyboardModifiers keyState, qint64 uniqueID);
    ~QTabletEvent();

    inline const QPoint &pos() const { return mPos; }
    inline const QPoint &globalPos() const { return mGPos; }
    inline const QPointF &hiResGlobalPos() const { return mHiResGlobalPos; }
    inline int x() const { return mPos.x(); }
    inline int y() const { return mPos.y(); }
    inline int globalX() const { return mGPos.x(); }
    inline int globalY() const { return mGPos.y(); }
    inline qreal hiResGlobalX() const { return mHiResGlobalPos.x(); }
    inline qreal hiResGlobalY() const { return mHiResGlobalPos.y(); }
    inline TabletDevice device() const { return TabletDevice(mDev); }
    inline PointerType pointerType() const { return PointerType(mPointerType); }
    inline qint64 uniqueId() const { return mUnique; }
    inline qreal pressure() const { return mPress; }
    inline int z() const { return mZ; }
    inline qreal tangentialPressure() const { return mTangential; }
    inline qreal rotation() const { return mRot; }
    inline int xTilt() const { return mXT; }
    inline int yTilt() const { return mYT; }

protected:
    QPoint mPos, mGPos;
    QPointF mHiResGlobalPos;
    int mDev, mPointerType, mXT, mYT, mZ;
    qreal mPress, mTangential, mRot;
    qint64 mUnique;

    
    
    
    void *mExtra;

};


class  QKeyEvent : public QInputEvent
{
public:
    QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers,
              const QString& text = QString(),
              bool autorep = false, ushort count = 1);
    ~QKeyEvent();

    int key() const { return k; }
    Qt::KeyboardModifiers modifiers() const;
    inline QString text() const { return txt; }
    inline bool isAutoRepeat() const { return autor; }
    inline int count() const { return int(c); }


    inline explicit QKeyEvent(Type type, int key, int  ,
                                           int modifiers, const QString& text = QString(),
                                           bool autorep = false, ushort count = 1)
        : QInputEvent(type, (Qt::KeyboardModifiers)(modifiers & (int)Qt::KeyButtonMask)), txt(text), k(key),
          c(count), autor(autorep)
    {
        if (key >= Qt::Key_Back && key <= Qt::Key_MediaLast)
            ignore();
    }
    inline  int ascii() const
    { return (txt.length() ? txt.unicode()->toLatin1() : 0); }
    inline  Qt::ButtonState state() const { return Qt::ButtonState(QInputEvent::modifiers()); }
    inline  Qt::ButtonState stateAfter() const { return Qt::ButtonState(modifiers()); }


protected:
    QString txt;
    int k;
    ushort c;
    uint autor:1;
};


class  QFocusEvent : public QEvent
{
public:
    QFocusEvent(Type type, Qt::FocusReason reason=Qt::OtherFocusReason);
    ~QFocusEvent();

    inline bool gotFocus() const { return type() == FocusIn; }
    inline bool lostFocus() const { return type() == FocusOut; }


    enum Reason { Mouse=Qt::MouseFocusReason, Tab=Qt::TabFocusReason,
                  Backtab=Qt::BacktabFocusReason, MenuBar=Qt::MenuBarFocusReason,
                  ActiveWindow=Qt::ActiveWindowFocusReason, Other=Qt::OtherFocusReason,
                  Popup=Qt::PopupFocusReason, Shortcut=Qt::ShortcutFocusReason };

    Qt::FocusReason reason();

private:
    Qt::FocusReason m_reason;
};


class  QPaintEvent : public QEvent
{
public:
    QPaintEvent(const QRegion& paintRegion);
    QPaintEvent(const QRect &paintRect);
    ~QPaintEvent();

    inline const QRect &rect() const { return m_rect; }
    inline const QRegion &region() const { return m_region; }


     QPaintEvent(const QRegion &paintRegion, const QRect &paintRect);
    inline  bool erased() const { return m_erased; }
    inline  void setErased(bool b) { m_erased = b; }


protected:
    friend class QApplication;
    friend class QCoreApplication;
    QRect m_rect;
    QRegion m_region;
    bool m_erased;
};

class QUpdateLaterEvent : public QEvent
{
public:
    QUpdateLaterEvent(const QRegion& paintRegion);
    ~QUpdateLaterEvent();

    inline const QRegion &region() const { return m_region; }

protected:
    QRegion m_region;
};

class  QMoveEvent : public QEvent
{
public:
    QMoveEvent(const QPoint &pos, const QPoint &oldPos);
    ~QMoveEvent();

    inline const QPoint &pos() const { return p; }
    inline const QPoint &oldPos() const { return oldp;}
protected:
    QPoint p, oldp;
    friend class QApplication;
    friend class QCoreApplication;
};


class  QResizeEvent : public QEvent
{
public:
    QResizeEvent(const QSize &size, const QSize &oldSize);
    ~QResizeEvent();

    inline const QSize &size() const { return s; }
    inline const QSize &oldSize()const { return olds;}
protected:
    QSize s, olds;
    friend class QApplication;
    friend class QCoreApplication;
};


class  QCloseEvent : public QEvent
{
public:
    QCloseEvent();
    ~QCloseEvent();
};


class  QIconDragEvent : public QEvent
{
public:
    QIconDragEvent();
    ~QIconDragEvent();
};


class  QShowEvent : public QEvent
{
public:
    QShowEvent();
    ~QShowEvent();
};


class  QHideEvent : public QEvent
{
public:
    QHideEvent();
    ~QHideEvent();
};


class  QContextMenuEvent : public QInputEvent
{
public:
    enum Reason { Mouse, Keyboard, Other };

    QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos);
    QContextMenuEvent(Reason reason, const QPoint &pos);
    ~QContextMenuEvent();

    inline int x() const { return p.x(); }
    inline int y() const { return p.y(); }
    inline int globalX() const { return gp.x(); }
    inline int globalY() const { return gp.y(); }

    inline const QPoint& pos() const { return p; }
    inline const QPoint& globalPos() const { return gp; }

    inline Reason reason() const { return Reason(reas); }


    explicit QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos, int);
    explicit QContextMenuEvent(Reason reason, const QPoint &pos, int);

     Qt::ButtonState state() const;

protected:
    QPoint p;
    QPoint gp;
    uint reas : 8;
};

class  QInputMethodEvent : public QEvent
{
public:
    enum AttributeType {
       TextFormat,
       Cursor,
       Language,
       Ruby
    };
    class Attribute {
    public:
        Attribute(AttributeType t, int s, int l, QVariant val) : type(t), start(s), length(l), value(val) {}
        AttributeType type;

        int start;
        int length;
        QVariant value;
    };
    QInputMethodEvent();
    QInputMethodEvent(const QString &preeditText, const QList<Attribute> &attributes);
    void setCommitString(const QString &commitString, int replaceFrom = 0, int replaceLength = 0);

    inline const QList<Attribute> &attributes() const { return attrs; }
    inline const QString &preeditString() const { return preedit; }

    inline const QString &commitString() const { return commit; }
    inline int replacementStart() const { return replace_from; }
    inline int replacementLength() const { return replace_length; }

    QInputMethodEvent(const QInputMethodEvent &other);

private:
    QString preedit;
    QList<Attribute> attrs;
    QString commit;
    int replace_from;
    int replace_length;
};



class QMimeData;

class  QDropEvent : public QEvent

                              , public QMimeSource

{
public:
    QDropEvent(const QPoint& pos, Qt::DropActions actions, const QMimeData *data,
               Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = Drop);
    ~QDropEvent();

    inline const QPoint &pos() const { return p; }
    inline Qt::MouseButtons mouseButtons() const { return mouseState; }
    inline Qt::KeyboardModifiers keyboardModifiers() const { return modState; }

    inline Qt::DropActions possibleActions() const { return act; }
    inline Qt::DropAction proposedAction() const { return default_action; }
    inline void acceptProposedAction() { drop_action = default_action; accept(); }

    inline Qt::DropAction dropAction() const { return drop_action; }
    void setDropAction(Qt::DropAction action);

    QWidget* source() const;
    inline const QMimeData *mimeData() const { return mdata; }


    const char* format(int n = 0) const;
    QByteArray encodedData(const char*) const;
    bool provides(const char*) const;


    inline void accept() { QEvent::accept(); }
    inline  void accept(bool y) { setAccepted(y); }
    inline  QByteArray data(const char* f) const { return encodedData(f); }

    enum Action { Copy, Link, Move, Private, UserAction = Private };
     Action action() const;
    inline  void acceptAction(bool y = true)  { if (y) { drop_action = default_action; accept(); } }
    inline  void setPoint(const QPoint& np) { p = np; }



protected:
    friend class QApplication;
    QPoint p;
    Qt::MouseButtons mouseState;
    Qt::KeyboardModifiers modState;
    Qt::DropActions act;
    Qt::DropAction drop_action;
    Qt::DropAction default_action;
    const QMimeData *mdata;
    mutable QList<QByteArray> fmts; 
};


class  QDragMoveEvent : public QDropEvent
{
public:
    QDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data,
                   Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = DragMove);
    ~QDragMoveEvent();

    inline QRect answerRect() const { return rect; }

    inline void accept() { QDropEvent::accept(); }
    inline void ignore() { QDropEvent::ignore(); }

    inline void accept(const QRect & r) { accept(); rect = r; }
    inline void ignore(const QRect & r) { ignore(); rect = r; }


    inline  void accept(bool y) { setAccepted(y); }


protected:
    friend class QApplication;
    QRect rect;
};


class  QDragEnterEvent : public QDragMoveEvent
{
public:
    QDragEnterEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data,
                    Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);
    ~QDragEnterEvent();
};


 
class  QDragResponseEvent : public QEvent
{
public:
    QDragResponseEvent(bool accepted);
    ~QDragResponseEvent();

    inline bool dragAccepted() const { return a; }
protected:
    bool a;
};


class  QDragLeaveEvent : public QEvent
{
public:
    QDragLeaveEvent();
    ~QDragLeaveEvent();
};



class  QHelpEvent : public QEvent
{
public:
    QHelpEvent(Type type, const QPoint &pos, const QPoint &globalPos);
    ~QHelpEvent();

    inline int x() const { return p.x(); }
    inline int y() const { return p.y(); }
    inline int globalX() const { return gp.x(); }
    inline int globalY() const { return gp.y(); }

    inline const QPoint& pos()  const { return p; }
    inline const QPoint& globalPos() const { return gp; }

private:
    QPoint p;
    QPoint gp;
};


class  QStatusTipEvent : public QEvent
{
public:
    QStatusTipEvent(const QString &tip);
    ~QStatusTipEvent();

    inline QString tip() const { return s; }
private:
    QString s;
};

class  QWhatsThisClickedEvent : public QEvent
{
public:
    QWhatsThisClickedEvent(const QString &href);
    ~QWhatsThisClickedEvent();

    inline QString href() const { return s; }
private:
    QString s;
};


class  QActionEvent : public QEvent
{
    QAction *act, *bef;
public:
    QActionEvent(int type, QAction *action, QAction *before = 0);
    ~QActionEvent();

    inline QAction *action() const { return act; }
    inline QAction *before() const { return bef; }
};


class  QFileOpenEvent : public QEvent
{
public:
    QFileOpenEvent(const QString &file);
    ~QFileOpenEvent();

    inline QString file() const { return f; }
private:
    QString f;
};

class  QToolBarChangeEvent : public QEvent
{
public:
    QToolBarChangeEvent(bool t);
    ~QToolBarChangeEvent();

    inline bool toggle() const { return tog; }
private:
    uint tog : 1;
};

class  QShortcutEvent : public QEvent
{
public:
    QShortcutEvent(const QKeySequence &key, int id, bool ambiguous = false);
    ~QShortcutEvent();

    inline const QKeySequence &key() { return sequence; }
    inline int shortcutId() { return sid; }
    inline bool isAmbiguous() { return ambig; }
protected:
    QKeySequence sequence;
    bool ambig;
    int  sid;
};

class  QClipboardEvent : public QEvent
{
public:
    QClipboardEvent(QEventPrivate *data);
    ~QClipboardEvent();

    QEventPrivate *data() { return d; };
};

class  QWindowStateChangeEvent: public QEvent
{
public:
    QWindowStateChangeEvent(Qt::WindowStates aOldState);
    QWindowStateChangeEvent(Qt::WindowStates aOldState, bool isOverride);
    ~QWindowStateChangeEvent();

    inline Qt::WindowStates oldState() const { return ostate; }
    bool isOverride() const;

private:
    Qt::WindowStates ostate;
};


class QMenuBar;
class  QMenubarUpdatedEvent: public QEvent
{
public:
    QMenubarUpdatedEvent(QMenuBar * const menBar);
    inline QMenuBar *menuBar() { return m_menuBar; }
private:
    QMenuBar *m_menuBar;
};



 QDebug operator<<(QDebug, const QEvent *);




#line 2 "../../include/QtGui/qevent.h"
#line 31 "../../include/QtGui/../../src/gui/text/qtextlayout.h"
#line 1 "../../include/QtGui/qtextformat.h"
#line 32 "../../include/QtGui/../../src/gui/text/qtextlayout.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QTextEngine;
class QFont;
class QRect;
class QRegion;
class QTextFormat;
class QPalette;
class QPainter;

class  QTextInlineObject
{
public:
    QTextInlineObject(int i, QTextEngine *e) : itm(i), eng(e) {}
    inline QTextInlineObject() : itm(0), eng(0) {}
    inline bool isValid() const { return eng; }

    QRectF rect() const;
    qreal width() const;
    qreal ascent() const;
    qreal descent() const;
    qreal height() const;

    Qt::LayoutDirection textDirection() const;

    void setWidth(qreal w);
    void setAscent(qreal a);
    void setDescent(qreal d);

    int textPosition() const;

    int formatIndex() const;
    QTextFormat format() const;

private:
    friend class QTextLayout;
    int itm;
    QTextEngine *eng;
};

class QPaintDevice;
class QTextFormat;
class QTextLine;
class QTextBlock;
class QTextOption;

class  QTextLayout
{
public:
    
    QTextLayout();
    QTextLayout(const QString& text);
    QTextLayout(const QString& text, const QFont &font, QPaintDevice *paintdevice = 0);
    QTextLayout(const QTextBlock &b);
    ~QTextLayout();

    void setFont(const QFont &f);
    QFont font() const;

    void setText(const QString& string);
    QString text() const;

    void setTextOption(const QTextOption &option);
    QTextOption textOption() const;

    void setPreeditArea(int position, const QString &text);
    int preeditAreaPosition() const;
    QString preeditAreaText() const;

    struct FormatRange {
        int start;
        int length;
        QTextCharFormat format;
    };
    void setAdditionalFormats(const QList<FormatRange> &overrides);
    QList<FormatRange> additionalFormats() const;
    void clearAdditionalFormats();

    void setCacheEnabled(bool enable);
    bool cacheEnabled() const;

    void beginLayout();
    void endLayout();

    QTextLine createLine();

    int lineCount() const;
    QTextLine lineAt(int i) const;
    QTextLine lineForTextPosition(int pos) const;

    enum CursorMode {
        SkipCharacters,
        SkipWords
    };
    bool isValidCursorPosition(int pos) const;
    int nextCursorPosition(int oldPos, CursorMode mode = SkipCharacters) const;
    int previousCursorPosition(int oldPos, CursorMode mode = SkipCharacters) const;

    void draw(QPainter *p, const QPointF &pos, const QVector<FormatRange> &selections = QVector<FormatRange>(),
              const QRectF &clip = QRectF()) const;
    void drawCursor(QPainter *p, const QPointF &pos, int cursorPosition) const;

    QPointF position() const;
    void setPosition(const QPointF &p);

    QRectF boundingRect() const;

    qreal minimumWidth() const;
    qreal maximumWidth() const;

    QTextEngine *engine() const { return d; }
private:
    QTextLayout(QTextEngine *e) : d(e) {}
    QTextLayout(const QTextLayout &); QTextLayout &operator=(const QTextLayout &);

    friend class QPainter;
    friend class QPSPrinter;
    friend void qt_format_text(const QFont &font, const QRectF &_r, int tf, const QString& str,
                               QRectF *brect, int tabstops, int* tabarray, int tabarraylen,
                               QPainter *painter);
    QTextEngine *d;
};


class  QTextLine
{
public:
    inline QTextLine() : i(0), eng(0) {}
    inline bool isValid() const { return eng; }

    QRectF rect() const;
    qreal x() const;
    qreal y() const;
    qreal width() const;
    qreal ascent() const;
    qreal descent() const;
    qreal height() const;

    qreal naturalTextWidth() const;
    QRectF naturalTextRect() const;

    enum Edge {
        Leading,
        Trailing
    };
    enum CursorPosition {
        CursorBetweenCharacters,
        CursorOnCharacter
    };

     
    qreal cursorToX(int *cursorPos, Edge edge = Leading) const;
    inline qreal cursorToX(int cursorPos, Edge edge = Leading) const { return cursorToX(&cursorPos, edge); }
    int xToCursor(qreal x, CursorPosition = CursorBetweenCharacters) const;

    void setLineWidth(qreal width);
    void setNumColumns(int columns);

    void setPosition(const QPointF &pos);

    int textStart() const;
    int textLength() const;

    int lineNumber() const { return i; }

    void draw(QPainter *p, const QPointF &point, const QTextLayout::FormatRange *selection = 0) const;

private:
    QTextLine(int line, QTextEngine *e) : i(line), eng(e) {}
    void layout_helper(int numGlyphs);
    friend class QTextLayout;
    int i;
    QTextEngine *eng;
};



#line 2 "../../include/QtGui/qtextlayout.h"
#line 40 "text/qtextengine_p.h"
#line 1 "../../include/QtGui/private/qtextformat_p.h"
#line 41 "text/qtextengine_p.h"
#line 1 "../../include/QtGui/private/qfont_p.h"
#line 1 "../../include/QtGui/private/../../../src/gui/text/qfont_p.h"



















 















#line 1 "../../include/QtCore/qmap.h"
#line 38 "../../include/QtGui/private/../../../src/gui/text/qfont_p.h"
#line 1 "../../include/QtCore/qobject.h"
#line 39 "../../include/QtGui/private/../../../src/gui/text/qfont_p.h"
#line 1 "../../include/QtCore/private/qunicodetables_p.h"
#line 1 "../../include/QtCore/private/../../../src/corelib/tools/qunicodetables_p.h"



















 















#line 1 "../../include/QtCore/qstring.h"
#line 37 "../../include/QtCore/private/../../../src/corelib/tools/qunicodetables_p.h"

namespace QUnicodeTables {
    struct Properties {
        uint category : 5;
        uint line_break_class : 5;
        uint direction : 5;
        uint titleCaseDiffersFromUpper : 1;
        uint combiningClass :8;
        uint unicode_version : 4;
        uint digit_value : 4;
        
        signed short mirrorDiff : 14  ;
        uint joining : 2;
        signed short caseDiff  ;
    };
     const Properties *  properties(ushort ucs2);
     const Properties *  properties(uint ucs4);

    
    
    enum LineBreakClass {
        LineBreak_OP, LineBreak_CL, LineBreak_QU, LineBreak_GL, LineBreak_NS,
        LineBreak_EX, LineBreak_SY, LineBreak_IS, LineBreak_PR, LineBreak_PO,
        LineBreak_NU, LineBreak_AL, LineBreak_ID, LineBreak_IN, LineBreak_HY,
        LineBreak_BA, LineBreak_BB, LineBreak_B2, LineBreak_ZW, LineBreak_CM,
        LineBreak_SA, LineBreak_BK, LineBreak_CR, LineBreak_LF, LineBreak_SG,
        LineBreak_CB, LineBreak_SP
    };

    inline uint surrogateToUcs4(ushort high, ushort low) {
        return (high<<10) + low - 0x35fdc00;
    }
    inline ushort highSurrogate(uint ucs4) {
        return (ucs4>>10) + 0xd7c0;
    }
    inline ushort lowSurrogate(uint ucs4) {
        return ucs4%0x400 + 0xdc00;
    }
    inline bool isHighSurrogate(uint utf16) {
        return (utf16 >= 0xd800 && utf16 < 0xdc00);
    }
    inline bool isLowSurrogate(uint utf16) {
        return (utf16 >= 0xdc00 && utf16 < 0xe000);
    }

     QChar::Category   category(ushort ucs2);
     unsigned char   combiningClass(ushort ucs2);
     QChar::Direction  direction(ushort ucs2);
     LineBreakClass  lineBreakClass(ushort ucs2);

     QChar::Category   category(uint ucs4);
     unsigned char   combiningClass(uint ucs4);
     QChar::Direction  direction(uint ucs4);
     LineBreakClass  lineBreakClass(uint ucs4);

     int  script(uint ucs4);
     int  script(ushort ucs2);
     inline int  script(const QChar &ch) {
        return script(ch.unicode());
    }

     QChar::UnicodeVersion  unicodeVersion(uint ucs4);
     QChar::Joining  joining(uint ucs4);
     bool  mirrored(uint ucs4);
     int  mirroredChar(uint ucs4);
     int  upper(uint ucs4);
     int  lower(uint ucs4);
     int  digitValue(uint ucs4);
     QString  decomposition(uint ucs4);
     QChar::Decomposition  decompositionTag(uint ucs4);
     ushort  ligature(ushort u1, ushort u2);

     QString normalize(const QString &str, QString::NormalizationForm mode);
     QString normalize(const QString &str, QString::NormalizationForm mode, QChar::UnicodeVersion version);

#line 1 "../../include/QtCore/private/../../../src/corelib/tools/qunicodedata_p.h"



















 

 














enum Script {
    Common,
    Hebrew,
    Arabic,
    Syriac,
    Thaana,
    Devanagari,
    Bengali,
    Gurmukhi,
    Gujarati,
    Oriya,
    Tamil,
    Telugu,
    Kannada,
    Malayalam,
    Sinhala,
    Thai,
    Lao,
    Tibetan,
    Myanmar,
    Hangul,
    Khmer,
    Inherited,
    ScriptCount = Inherited,
    Latin = Common,
    Greek = Common,
    Cyrillic = Common,
    Armenian = Common,
    Georgian = Common,
    Ethiopic = Common,
    Cherokee = Common,
    CanadianAboriginal = Common,
    Ogham = Common,
    Runic = Common,
    Tagalog = Common,
    Hanunoo = Common,
    Buhid = Common,
    Tagbanwa = Common,
    Mongolian = Common,
    Limbu = Common,
    TaiLe = Common,
    Braille = Common,
    Hiragana = Common,
    Katakana = Common,
    Bopomofo = Common,
    Kanbun = Common,
    Yi = Common,
    Han = Common,
    OldItalic = Common,
    Gothic = Common,
    Deseret = Common,
    LinearB = Common,
    Ugaritic = Common,
    Shavian = Common,
    Osmanya = Common,
    Cypriot = Common,
    KatakanaOrHiragana = Common
};

enum { ScriptSentinel = 32 };

#line 113 "../../include/QtCore/private/../../../src/corelib/tools/qunicodetables_p.h"

}


inline QChar::Category category(const QChar &c)
{
    return QUnicodeTables::category(c.unicode());
}

inline QChar lower(const QChar &c)
{
    return QChar(QUnicodeTables::lower(c.unicode()));
}

inline QChar upper(const QChar &c)
{
    return QChar(QUnicodeTables::upper(c.unicode()));
}

inline QChar::Direction direction(const QChar &c)
{
    return QUnicodeTables::direction(c.unicode());
}

inline bool mirrored(const QChar &c)
{
    return QUnicodeTables::mirrored(c.unicode());
}


inline QChar mirroredChar(const QChar &c)
{
    return QUnicodeTables::mirroredChar(c.unicode());
}

inline QChar::Joining joining(const QChar &c)
{
    return QUnicodeTables::joining(c.unicode());
}

inline bool isMark(const QChar &ch)
{
    QChar::Category c = QUnicodeTables::category(ch.unicode());
    return c >= QChar::Mark_NonSpacing && c <= QChar::Mark_Enclosing;
}

inline unsigned char combiningClass(const QChar &ch)
{
    return QUnicodeTables::combiningClass(ch.unicode());
}

inline bool isSpace(const QChar &ch)
{
    if(ch.unicode() >= 9 && ch.unicode() <=13) return true;
    QChar::Category c = QUnicodeTables::category(ch.unicode());
    return c >= QChar::Separator_Space && c <= QChar::Separator_Paragraph;
}

inline int lineBreakClass(const QChar &ch)
{
    return QUnicodeTables::lineBreakClass(ch.unicode());
}

#line 2 "../../include/QtCore/private/qunicodetables_p.h"
#line 40 "../../include/QtGui/private/../../../src/gui/text/qfont_p.h"
#line 1 "../../include/QtGui/qfontdatabase.h"
#line 1 "../../include/QtGui/../../src/gui/text/qfontdatabase.h"



















 




#line 1 "../../include/QtGui/qwindowdefs.h"
#line 26 "../../include/QtGui/../../src/gui/text/qfontdatabase.h"
#line 1 "../../include/QtCore/qstring.h"
#line 27 "../../include/QtGui/../../src/gui/text/qfontdatabase.h"
#line 1 "../../include/QtGui/qfont.h"
#line 28 "../../include/QtGui/../../src/gui/text/qfontdatabase.h"
#line 1 "../../include/QtCore/qstringlist.h"
#line 30 "../../include/QtGui/../../src/gui/text/qfontdatabase.h"
#line 1 "../../include/QtCore/qlist.h"
#line 31 "../../include/QtGui/../../src/gui/text/qfontdatabase.h"




typedef QtValidLicenseForGuiModule QtGuiModule;

class QStringList;
template <class T> class QList;
struct QFontDef;
class QFontEngine;

class QFontDatabasePrivate;

class  QFontDatabase
{
public:
    enum WritingSystem {
        Any,

        Latin,
        Greek,
        Cyrillic,
        Armenian,
        Hebrew,
        Arabic,
        Syriac,
        Thaana,
        Devanagari,
        Bengali,
        Gurmukhi,
        Gujarati,
        Oriya,
        Tamil,
        Telugu,
        Kannada,
        Malayalam,
        Sinhala,
        Thai,
        Lao,
        Tibetan,
        Myanmar,
        Georgian,
        Khmer,
        SimplifiedChinese,
        TraditionalChinese,
        Japanese,
        Korean,
        Vietnamese,

        Other,

        WritingSystemsCount
    };

    static QList<int> standardSizes();

    QFontDatabase();

    QList<WritingSystem> writingSystems() const;
    QStringList families(WritingSystem writingSystem = Any) const;
    QStringList styles(const QString &family) const;
    QList<int> pointSizes(const QString &family, const QString &style = QString());
    QList<int> smoothSizes(const QString &family, const QString &style);
    QString styleString(const QFont &font);
    QString styleString(const QFontInfo &fontInfo);

    QFont font(const QString &family, const QString &style, int pointSize) const;

    bool isBitmapScalable(const QString &family, const QString &style = QString()) const;
    bool isSmoothlyScalable(const QString &family, const QString &style = QString()) const;
    bool isScalable(const QString &family, const QString &style = QString()) const;
    bool isFixedPitch(const QString &family, const QString &style = QString()) const;

    bool italic(const QString &family, const QString &style) const;
    bool bold(const QString &family, const QString &style) const;
    int weight(const QString &family, const QString &style) const;

    static QString writingSystemName(WritingSystem writingSystem);
    static QString writingSystemSample(WritingSystem writingSystem);

private:
    static void createDatabase();
    static void parseFontName(const QString &name, QString &foundry, QString &family);




    static void load(const QFontPrivate *d, int script);


    static QFontEngine *loadXlfd(int screen, int script, const QFontDef &request, int force_encoding_id = -1);

    
    friend struct QFontDef;
    friend class QFontPrivate;
    friend class QFontDialog;
    friend class QFontEngineMultiXLFD;

    QFontDatabasePrivate *d;
};



#line 2 "../../include/QtGui/qfontdatabase.h"
#line 41 "../../include/QtGui/private/../../../src/gui/text/qfont_p.h"


class QFontEngine;

struct QFontDef
{
    inline QFontDef()
        : pointSize(-1.0), pixelSize(-1),
          styleStrategy(QFont::PreferDefault), styleHint(QFont::AnyStyle),
          weight(50), fixedPitch(false), style(QFont::StyleNormal), stretch(100),
          ignorePitch(true)



    {
    }

    QString family;


    QString addStyle;


    qreal pointSize;
    int pixelSize;

    uint styleStrategy : 16;
    uint styleHint     : 8;

    uint weight     :  7; 
    uint fixedPitch :  1;
    uint style      :  2;
    uint stretch    : 12; 

    uint ignorePitch : 1;
    uint fixedPitchComputed : 1; 
    uint reserved   : 16; 

    bool exactMatch(const QFontDef &other) const;
    bool operator==(const QFontDef &other) const
    {
        return pixelSize == other.pixelSize
                    && weight == other.weight
                    && style == other.style
                    && stretch == other.stretch
                    && styleHint == other.styleHint
                    && styleStrategy == other.styleStrategy
                    && family == other.family

                    && addStyle == other.addStyle

                          ;
    }
    inline bool operator<(const QFontDef &other) const
    {
        if (pixelSize != other.pixelSize) return pixelSize < other.pixelSize;
        if (weight != other.weight) return weight < other.weight;
        if (style != other.style) return style < other.style;
        if (stretch != other.stretch) return stretch < other.stretch;
        if (styleHint != other.styleHint) return styleHint < other.styleHint;
        if (styleStrategy != other.styleStrategy) return styleStrategy < other.styleStrategy;
        if (family != other.family) return family < other.family;


        if (addStyle != other.addStyle) return addStyle < other.addStyle;


        return false;
    }
};

class QFontEngineData
{
public:
    QFontEngineData();
    ~QFontEngineData();

    QAtomic ref;
    uint lineWidth;


    QFontEngine *engines[QUnicodeTables::ScriptCount];




    enum { widthCacheSize = 0x500 };
    uchar widthCache[widthCacheSize];

};


class  QFontPrivate
{
public:

    static int defaultEncodingID;


    QFontPrivate();
    QFontPrivate(const QFontPrivate &other);
    ~QFontPrivate();





    inline QFontEngine *engineForScript(int script) const
    {
        if (script >= QUnicodeTables::Inherited)
            script = QUnicodeTables::Common;
        if (!engineData || !engineData->engines[script])
            QFontDatabase::load(this, script);
        return engineData->engines[script];
    }
#line 166 "../../include/QtGui/private/../../../src/gui/text/qfont_p.h"

    QAtomic ref;
    QFontDef request;
    mutable QFontEngineData *engineData;
    int dpi;
    int screen;

    uint rawMode    :  1;
    uint underline  :  1;
    uint overline   :  1;
    uint strikeOut  :  1;
    uint kerning    :  1;

    enum {
        Family        = 0x0001,
        Size          = 0x0002,
        StyleHint     = 0x0004,
        StyleStrategy = 0x0008,
        Weight        = 0x0010,
        Style         = 0x0020,
        Underline     = 0x0040,
        Overline      = 0x0080,
        StrikeOut     = 0x0100,
        FixedPitch    = 0x0200,
        Stretch       = 0x0400,
        Kerning       = 0x0800,
        Complete      = 0x0fff
    };

    void resolve(uint mask, const QFontPrivate *other);
};


class QFontCache : public QObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:
public:
    static QFontCache *instance;

    QFontCache();
    ~QFontCache();




    
    
    struct Key {
        Key() : script(0), screen(0) { }
        Key(const QFontDef &d, int c, int s = 0)
            : def(d), script(c), screen(s) { }

        QFontDef def;
        int script;
        int screen;

        inline bool operator<(const Key &other) const
        {
            if (script != other.script) return script < other.script;
            if (screen != other.screen) return screen < other.screen;
            return def < other.def;
        }
        inline bool operator==(const Key &other) const
        { return def == other.def && script == other.script && screen == other.screen; }
    };

    
    typedef QMap<Key,QFontEngineData*> EngineDataCache;
    EngineDataCache engineDataCache;

    QFontEngineData *findEngineData(const Key &key) const;
    void insertEngineData(const Key &key, QFontEngineData *engineData);

    
    struct Engine {
        Engine() : data(0), timestamp(0), hits(0) { }
        Engine(QFontEngine *d) : data(d), timestamp(0), hits(0) { }

        QFontEngine *data;
        uint timestamp;
        uint hits;
    };

    typedef QMap<Key,Engine> EngineCache;
    EngineCache engineCache;

    QFontEngine *findEngine(const Key &key);
    void insertEngine(const Key &key, QFontEngine *engine);





    private:
    void increaseCost(uint cost);
    void decreaseCost(uint cost);
    void timerEvent(QTimerEvent *event);

    static const uint min_cost;
    uint total_cost, max_cost;
    uint current_timestamp;
    bool fast;
    int timer_id;
};

#line 2 "../../include/QtGui/private/qfont_p.h"
#line 42 "text/qtextengine_p.h"
#line 1 "../../include/QtCore/qvector.h"
#line 43 "text/qtextengine_p.h"
#line 1 "../../include/QtGui/qpaintengine.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qpaintengine.h"



















 




#line 1 "../../include/QtCore/qnamespace.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qpaintengine.h"
#line 1 "../../include/QtCore/qobjectdefs.h"
#line 27 "../../include/QtGui/../../src/gui/painting/qpaintengine.h"
#line 1 "../../include/QtGui/qpainter.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qpainter.h"



















 




#line 1 "../../include/QtCore/qnamespace.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtCore/qrect.h"
#line 27 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtCore/qpoint.h"
#line 28 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtGui/qpixmap.h"
#line 1 "../../include/QtGui/../../src/gui/image/qpixmap.h"



















 




#line 1 "../../include/QtGui/qpaintdevice.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qpaintdevice.h"



















 




#line 1 "../../include/QtGui/qwindowdefs.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qpaintdevice.h"
#line 1 "../../include/QtCore/qrect.h"
#line 27 "../../include/QtGui/../../src/gui/painting/qpaintdevice.h"



typedef QtValidLicenseForGuiModule QtGuiModule;





class QPaintEngine;

class  QPaintDevice                                
{
public:
    enum PaintDeviceMetric {
        PdmWidth = 1,
        PdmHeight,
        PdmWidthMM,
        PdmHeightMM,
        PdmNumColors,
        PdmDepth,
        PdmDpiX,
        PdmDpiY,
        PdmPhysicalDpiX,
        PdmPhysicalDpiY
    };

    virtual ~QPaintDevice();

    virtual int devType() const;
    bool paintingActive() const;
    virtual QPaintEngine *paintEngine() const = 0;










    int width() const { return metric(PdmWidth); }
    int height() const { return metric(PdmHeight); }
    int widthMM() const { return metric(PdmWidthMM); }
    int heightMM() const { return metric(PdmHeightMM); }
    int logicalDpiX() const { return metric(PdmDpiX); }
    int logicalDpiY() const { return metric(PdmDpiY); }
    int physicalDpiX() const { return metric(PdmPhysicalDpiX); }
    int physicalDpiY() const { return metric(PdmPhysicalDpiY); }
    int numColors() const { return metric(PdmNumColors); }
    int depth() const { return metric(PdmDepth); }

protected:
    QPaintDevice();
    virtual int metric(PaintDeviceMetric metric) const;

    ushort        painters;                        

private:
    QPaintDevice(const QPaintDevice &); QPaintDevice &operator=(const QPaintDevice &);


public:
     Display *x11Display() const;
     int x11Screen() const;
     int x11Depth() const;
     int x11Cells() const;
     Qt::HANDLE x11Colormap() const;
     bool x11DefaultColormap() const;
     void *x11Visual() const;
     bool x11DefaultVisual() const;

    static  Display *x11AppDisplay();
    static  int x11AppScreen();
    static  int x11AppDepth(int screen = -1);
    static  int x11AppCells(int screen = -1);
    static  Qt::HANDLE x11AppRootWindow(int screen = -1);
    static  Qt::HANDLE x11AppColormap(int screen = -1);
    static  void *x11AppVisual(int screen = -1);
    static  bool x11AppDefaultColormap(int screen =-1);
    static  bool x11AppDefaultVisual(int screen =-1);
    static  int x11AppDpiX(int screen = -1);
    static  int x11AppDpiY(int screen = -1);
    static  void x11SetAppDpiX(int, int);
    static  void x11SetAppDpiY(int, int);


    friend class QPainter;
    friend class QQuickDrawPaintEngine;
    friend class QFontEngineMac;
    friend class QX11PaintEngine;
};


 
void bitBlt(QPaintDevice *dst, int dx, int dy,
             const QPaintDevice *src, int sx=0, int sy=0, int sw=-1, int sh=-1,
             bool ignoreMask=false);

 
void bitBlt(QPaintDevice *dst, int dx, int dy,
             const QImage *src, int sx=0, int sy=0, int sw=-1, int sh=-1,
             int conversion_flags=0);

 
void bitBlt(QPaintDevice *dst, const QPoint &dp,
            const QPaintDevice *src, const QRect &sr=QRect(0,0,-1,-1),
            bool ignoreMask=false);




 

inline int QPaintDevice::devType() const
{ return QInternal::UnknownDevice; }

inline bool QPaintDevice::paintingActive() const
{ return painters != 0; }



#line 2 "../../include/QtGui/qpaintdevice.h"
#line 26 "../../include/QtGui/../../src/gui/image/qpixmap.h"
#line 1 "../../include/QtGui/qcolor.h"
#line 27 "../../include/QtGui/../../src/gui/image/qpixmap.h"
#line 1 "../../include/QtCore/qnamespace.h"
#line 28 "../../include/QtGui/../../src/gui/image/qpixmap.h"
#line 1 "../../include/QtCore/qstring.h"
#line 29 "../../include/QtGui/../../src/gui/image/qpixmap.h"
#line 1 "../../include/QtGui/qimage.h"
#line 1 "../../include/QtGui/../../src/gui/image/qimage.h"



















 




#line 1 "../../include/QtGui/qpaintdevice.h"
#line 26 "../../include/QtGui/../../src/gui/image/qimage.h"
#line 1 "../../include/QtGui/qrgb.h"
#line 27 "../../include/QtGui/../../src/gui/image/qimage.h"
#line 1 "../../include/QtCore/qbytearray.h"
#line 28 "../../include/QtGui/../../src/gui/image/qimage.h"
#line 1 "../../include/QtCore/qrect.h"
#line 29 "../../include/QtGui/../../src/gui/image/qimage.h"
#line 1 "../../include/QtCore/qstring.h"
#line 30 "../../include/QtGui/../../src/gui/image/qimage.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QIODevice;
class QStringList;
class QMatrix;
class QVariant;
template <class T> class QList;
template <class T> class QVector;

struct QImageData;
class QImageDataMisc; 

class  QImageTextKeyLang {
public:
    QImageTextKeyLang(const char* k, const char* l) : key(k), lang(l) { }
    QImageTextKeyLang() { }

    QByteArray key;
    QByteArray lang;

    bool operator< (const QImageTextKeyLang& other) const
        { return key < other.key || key==other.key && lang < other.lang; }
    bool operator== (const QImageTextKeyLang& other) const
        { return key==other.key && lang==other.lang; }
};



class  QImage : public QPaintDevice
{
public:
    enum InvertMode { InvertRgb, InvertRgba };
    enum Format {
        Format_Invalid,
        Format_Mono,
        Format_MonoLSB,
        Format_Indexed8,
        Format_RGB32,
        Format_ARGB32,
        Format_ARGB32_Premultiplied, 
#line 87 "../../include/QtGui/../../src/gui/image/qimage.h"
        NImageFormats

    };

    QImage();
    QImage(const QSize &size, Format format);
    QImage(int width, int height, Format format);
    QImage(uchar *data, int width, int height, Format format);


    explicit QImage(const char * const xpm[]);

    explicit QImage(const QString &fileName, const char *format = 0);

    explicit QImage(const char *fileName, const char *format = 0);


    QImage(const QImage &);
    ~QImage();

    QImage &operator=(const QImage &);
    bool isNull() const;

    int devType() const;

    bool operator==(const QImage &) const;
    bool operator!=(const QImage &) const;
    operator QVariant() const;
    void detach();
    bool isDetached() const;

    QImage copy(const QRect &rect = QRect()) const;
    inline QImage copy(int x, int y, int w, int h) const
        { return copy(QRect(x, y, w, h)); }

    Format format() const;

    QImage convertToFormat(Format f, Qt::ImageConversionFlags flags = Qt::AutoColor) const;
    QImage convertToFormat(Format f, const QVector<QRgb> &colorTable, Qt::ImageConversionFlags flags = Qt::AutoColor) const;

    int width() const;
    int height() const;
    QSize size() const;
    QRect rect() const;

    int depth() const;
    int numColors() const;

    QRgb color(int i) const;
    void setColor(int i, QRgb c);
    void setNumColors(int);

    bool allGray() const;
    bool isGrayscale() const;

    uchar *bits();
    const uchar *bits() const;
    int numBytes() const;

    uchar *scanLine(int);
    const uchar *scanLine(int) const;
    int bytesPerLine() const;

    bool valid(int x, int y) const;
    int pixelIndex(int x, int y) const;
    QRgb pixel(int x, int y) const;
    void setPixel(int x, int y, uint index_or_rgb);

    QVector<QRgb> colorTable() const;
    void setColorTable(const QVector<QRgb> colors);

    void fill(uint pixel);

    bool hasAlphaChannel() const;
    void setAlphaChannel(const QImage &alphaChannel);
    QImage alphaChannel() const;
    QImage createAlphaMask(Qt::ImageConversionFlags flags = Qt::AutoColor) const;

    QImage createHeuristicMask(bool clipTight = true) const;


    inline QImage scaled(int w, int h, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
                        Qt::TransformationMode mode = Qt::FastTransformation) const
        { return scaled(QSize(w, h), aspectMode, mode); }
    QImage scaled(const QSize &s, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
                 Qt::TransformationMode mode = Qt::FastTransformation) const;
    QImage scaledToWidth(int w, Qt::TransformationMode mode = Qt::FastTransformation) const;
    QImage scaledToHeight(int h, Qt::TransformationMode mode = Qt::FastTransformation) const;
    QImage transformed(const QMatrix &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const;
    static QMatrix trueMatrix(const QMatrix &, int w, int h);
    QImage mirrored(bool horizontally = false, bool vertically = true) const;
    QImage rgbSwapped() const;
    void invertPixels(InvertMode = InvertRgb);


    bool load(QIODevice *device, const char* format);
    bool load(const QString &fileName, const char* format=0);
    bool loadFromData(const uchar *buf, int len, const char *format = 0);
    inline bool loadFromData(const QByteArray &data, const char* aformat=0)
        { return loadFromData(reinterpret_cast<const uchar *>(data.constData()), data.size(), aformat); }

    bool save(const QString &fileName, const char* format, int quality=-1) const;
    bool save(QIODevice *device, const char* format, int quality=-1) const;

    static QImage fromData(const uchar *data, int size, const char *format = 0);
    inline static QImage fromData(const QByteArray &data, const char *format = 0)
        { return fromData(reinterpret_cast<const uchar *>(data.constData()), data.size(), format); }

    int serialNumber() const;

    QPaintEngine *paintEngine() const;

    
    int dotsPerMeterX() const;
    int dotsPerMeterY() const;
    void setDotsPerMeterX(int);
    void setDotsPerMeterY(int);
    QPoint offset() const;
    void setOffset(const QPoint&);

    QStringList textKeys() const;
    QString text(const QString &key = QString()) const;
    void setText(const QString &key, const QString &value);

    
    QString text(const char* key, const char* lang=0) const;
    QList<QImageTextKeyLang> textList() const;
    QStringList textLanguages() const;
    QString text(const QImageTextKeyLang&) const;
    void setText(const char* key, const char* lang, const QString&);



    enum Endian { BigEndian, LittleEndian, IgnoreEndian };
    explicit QImage(int width, int height, int depth, int numColors=0, Endian bitOrder=IgnoreEndian);
    explicit QImage(const QSize&, int depth, int numColors=0, Endian bitOrder=IgnoreEndian);
    explicit QImage(uchar *data, int w, int h, int depth, const QRgb *colortable, int numColors, Endian bitOrder);



    inline  Endian bitOrder() const {
        Format f = format();
        return f == Format_Mono ? BigEndian : (f == Format_MonoLSB ? LittleEndian : IgnoreEndian);
    }
     QImage convertDepth(int, Qt::ImageConversionFlags flags = Qt::AutoColor) const;
     QImage convertDepthWithPalette(int, QRgb* p, int pc, Qt::ImageConversionFlags flags = Qt::AutoColor) const;
     QImage convertBitOrder(Endian) const;
     bool hasAlphaBuffer() const;
     void setAlphaBuffer(bool);
     uchar **jumpTable();
     const uchar * const *jumpTable() const;
    inline  void reset() { *this = QImage(); }
    static inline  Endian systemByteOrder()
        { return QSysInfo::ByteOrder == QSysInfo::BigEndian ? BigEndian : LittleEndian; }
    inline  QImage swapRGB() const { return rgbSwapped(); }
    inline  QImage mirror(bool horizontally = false, bool vertically = true) const
        { return mirrored(horizontally, vertically); }
     bool create(const QSize&, int depth, int numColors=0, Endian bitOrder=IgnoreEndian);
     bool create(int width, int height, int depth, int numColors=0, Endian bitOrder=IgnoreEndian);
    inline  QImage xForm(const QMatrix &matrix) const { return transformed(matrix); }
    inline  QImage smoothScale(int w, int h, Qt::AspectRatioMode mode = Qt::IgnoreAspectRatio) const
        { return scaled(QSize(w, h), mode, Qt::SmoothTransformation); }
    inline QImage  smoothScale(const QSize &s, Qt::AspectRatioMode mode = Qt::IgnoreAspectRatio) const
        { return scaled(s, mode, Qt::SmoothTransformation); }
    inline  QImage scaleWidth(int w) const { return scaledToWidth(w); }
    inline  QImage scaleHeight(int h) const { return scaledToHeight(h); }
    inline  void invertPixels(bool invertAlpha) { invertAlpha ? invertPixels(InvertRgba) : invertPixels(InvertRgb); }
    inline  QImage copy(int x, int y, int w, int h, Qt::ImageConversionFlags) const
        { return copy(QRect(x, y, w, h)); }
    inline  QImage copy(const QRect &rect, Qt::ImageConversionFlags) const
        { return copy(rect); }
    static  Endian systemBitOrder();
    inline explicit QImage(const QByteArray &data)
        { d = 0; *this = QImage::fromData(data); }


protected:
    virtual int metric(PaintDeviceMetric metric) const;

private:
#line 273 "../../include/QtGui/../../src/gui/image/qimage.h"

    QImageData *d;

    friend class QPixmap;
    friend  qint64 qt_image_id(const QImage &image);
    friend const QVector<QRgb> *qt_image_colortable(const QImage &image);
};

template <> inline bool qIsDetached<QImage>(QImage &t) { return t . isDetached(); }
template <> class QTypeInfo<QImage> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QImage)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QImage"; } };




 QDataStream &operator<<(QDataStream &, const QImage &);
 QDataStream &operator>>(QDataStream &, QImage &);



  void bitBlt(QImage* dst, int dx, int dy, const QImage* src,
                                     int sx=0, int sy=0, int sw=-1, int sh=-1, Qt::ImageConversionFlags flags = Qt::AutoColor);




#line 2 "../../include/QtGui/qimage.h"
#line 30 "../../include/QtGui/../../src/gui/image/qpixmap.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QImageWriter;
class QPixmapPrivate;
class QColor;
class QVariant;
class QX11Info;

struct QPixmapData;

class  QPixmap : public QPaintDevice
{
public:
    QPixmap();
    QPixmap(int w, int h);
    QPixmap(const QSize &);
    QPixmap(const QString& fileName, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);

    QPixmap(const char * const xpm[]);

    QPixmap(const QPixmap &);
    ~QPixmap();

    QPixmap &operator=(const QPixmap &);
    operator QVariant() const;

    bool isNull() const;
    int devType() const;

    int width() const;
    int height() const;
    QSize size() const;
    QRect rect() const;
    int depth() const;

    static int defaultDepth();

    void fill(const QColor &fillColor = Qt::white);
    void fill(const QWidget *widget, const QPoint &ofs);
    inline void fill(const QWidget *widget, int xofs, int yofs) { fill(widget, QPoint(xofs, yofs)); }

    QBitmap mask() const;
    void setMask(const QBitmap &);

    QPixmap alphaChannel() const;
    void setAlphaChannel(const QPixmap &);

    bool hasAlpha() const;
    bool hasAlphaChannel() const;


    QBitmap createHeuristicMask(bool clipTight = true) const;

    QBitmap createMaskFromColor(const QColor &maskColor) const;

    static QPixmap grabWindow(WId, int x=0, int y=0, int w=-1, int h=-1);
    static QPixmap grabWidget(QWidget *widget, const QRect &rect);
    static inline QPixmap grabWidget(QWidget *widget, int x=0, int y=0, int w=-1, int h=-1)
    { return grabWidget(widget, QRect(x, y, w, h)); }


    inline QPixmap scaled(int w, int h, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
                          Qt::TransformationMode mode = Qt::FastTransformation) const
        { return scaled(QSize(w, h), aspectMode, mode); }
    QPixmap scaled(const QSize &s, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
                   Qt::TransformationMode mode = Qt::FastTransformation) const;
    QPixmap scaledToWidth(int w, Qt::TransformationMode mode = Qt::FastTransformation) const;
    QPixmap scaledToHeight(int h, Qt::TransformationMode mode = Qt::FastTransformation) const;
    QPixmap transformed(const QMatrix &, Qt::TransformationMode mode = Qt::FastTransformation) const;
    static QMatrix trueMatrix(const QMatrix &m, int w, int h);

    QImage toImage() const;
    static QPixmap fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor);

    bool load(const QString& fileName, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
    bool loadFromData(const uchar *buf, uint len, const char* format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
    inline bool loadFromData(const QByteArray &data, const char* format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
    bool save(const QString& fileName, const char* format, int quality = -1) const;
    bool save(QIODevice* device, const char* format, int quality = -1) const;

#line 122 "../../include/QtGui/../../src/gui/image/qpixmap.h"

    inline QPixmap copy(int x, int y, int width, int height) const;
    QPixmap copy(const QRect &rect = QRect()) const;

    int serialNumber() const;

    bool isDetached() const;
    void detach();

    inline bool isQBitmap() const { return depth() == 1; }

#line 143 "../../include/QtGui/../../src/gui/image/qpixmap.h"
    static int x11SetDefaultScreen(int screen);
    void x11SetScreen(int screen);
    const QX11Info &x11Info() const;
    Qt::HANDLE x11PictureHandle() const;



    Qt::HANDLE handle() const;


    QPaintEngine *paintEngine() const;

    inline bool operator!() const { return isNull(); }

protected:
    int metric(PaintDeviceMetric) const;


public:
    enum ColorMode { Auto, Color, Mono };
    explicit QPixmap(const QString& fileName, const char *format, ColorMode mode);
     bool load(const QString& fileName, const char *format, ColorMode mode);
     bool loadFromData(const uchar *buf, uint len, const char* format, ColorMode mode);
    explicit QPixmap(const QImage& image);
     QPixmap &operator=(const QImage &);
    inline  QImage convertToImage() const { return toImage(); }
     bool convertFromImage(const QImage &, ColorMode mode);
     bool convertFromImage(const QImage &img, Qt::ImageConversionFlags flags = Qt::AutoColor)
        { (*this) = fromImage(img, flags); return !isNull(); }
    inline  operator QImage() const { return toImage(); }
    inline  QPixmap xForm(const QMatrix &matrix) const { return transformed(matrix); }
    inline  bool selfMask() const { return false; }
private:
    void resize_helper(const QSize &s);
public:
    inline  void resize(const QSize &s) { resize_helper(s); }
    inline  void resize(int width, int height) { resize_helper(QSize(width, height)); }


private:
    QPixmapData *data;

    bool doImageIO(QImageWriter *io, int quality) const;
    enum Type { PixmapType, BitmapType };
    QPixmap(const QSize &s, Type);

    void init(int, int, Type = PixmapType);
    void deref();



    
#line 201 "../../include/QtGui/../../src/gui/image/qpixmap.h"
    friend struct QPixmapData;
    friend class QBitmap;
    friend class QPaintDevice;
    friend class QPainter;
    friend class QGLWidget;
    friend class QX11PaintEngine;
    friend class QQuickDrawPaintEngine;
    friend class QCoreGraphicsPaintEngine;
    friend class QWidgetPrivate;
    friend class QRasterPaintEngine;

    friend  QDataStream &operator>>(QDataStream &, QPixmap &);

    friend  qint64 qt_pixmap_id(const QPixmap &pixmap);
};

template <> inline bool qIsDetached<QPixmap>(QPixmap &t) { return t . isDetached(); }

inline QPixmap QPixmap::copy(int ax, int ay, int awidth, int aheight) const
{
    return copy(QRect(ax, ay, awidth, aheight));
}

inline bool QPixmap::loadFromData(const QByteArray &buf, const char *format,
                                  Qt::ImageConversionFlags flags)
{
    return loadFromData(reinterpret_cast<const uchar *>(buf.constData()), buf.size(), format, flags);
}



 


 QDataStream &operator<<(QDataStream &, const QPixmap &);
 QDataStream &operator>>(QDataStream &, QPixmap &);




 

  void copyBlt(QPixmap *dst, int dx, int dy, const QPixmap *src,
                                    int sx=0, int sy=0, int sw=-1, int sh=-1);




#line 2 "../../include/QtGui/qpixmap.h"
#line 29 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtGui/qimage.h"
#line 30 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtGui/qtextoption.h"
#line 1 "../../include/QtGui/../../src/gui/text/qtextoption.h"



















 




#line 1 "../../include/QtCore/qnamespace.h"
#line 26 "../../include/QtGui/../../src/gui/text/qtextoption.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

template <typename T> class QList;
struct QTextOptionPrivate;

class  QTextOption
{
public:
    QTextOption();
    QTextOption(Qt::Alignment alignment);
    ~QTextOption();

    QTextOption(const QTextOption &o);
    QTextOption &operator=(const QTextOption &o);

    inline void setAlignment(Qt::Alignment alignment);
    inline Qt::Alignment alignment() const { return Qt::Alignment(align); }

    inline void setTextDirection(Qt::LayoutDirection aDirection) { this->direction = aDirection; }
    inline Qt::LayoutDirection textDirection() const { return Qt::LayoutDirection(direction); }

    enum WrapMode {
        NoWrap,
        WordWrap,
        ManualWrap,
        WrapAnywhere,
        WrapAtWordBoundaryOrAnywhere
    };
    inline void setWrapMode(WrapMode wrap) { wordWrap = wrap; }
    inline WrapMode wrapMode() const { return static_cast<WrapMode>(wordWrap); }

    enum Flag {
        IncludeTrailingSpaces = 0x80000000
    };
    typedef QFlags<Flag> Flags;
    inline void setFlags(Flags flags);
    inline Flags flags() const { return Flags(f); }

    inline void setTabStop(qreal tabStop);
    inline qreal tabStop() const { return tab; }

    void setTabArray(QList<qreal> tabStops);
    QList<qreal> tabArray() const;

    void setUseDesignMetrics(bool b) { design = b; }
    bool useDesignMetrics() const { return design; }

private:
    uint align : 8;
    uint wordWrap : 4;
    uint design : 1;
    uint direction : 1;
    uint unused : 19;
    uint f;
    qreal tab;
    QTextOptionPrivate *d;
};

inline QFlags<QTextOption::Flags::enum_type> operator|(QTextOption::Flags::enum_type f1, QTextOption::Flags::enum_type f2) { return QFlags<QTextOption::Flags::enum_type>(f1) | f2; } inline QFlags<QTextOption::Flags::enum_type> operator|(QTextOption::Flags::enum_type f1, QFlags<QTextOption::Flags::enum_type> f2) { return f2 | f1; }

inline void QTextOption::setAlignment(Qt::Alignment aalignment)
{ align = aalignment; }

inline void QTextOption::setFlags(Flags aflags)
{ f = aflags; }

inline void QTextOption::setTabStop(qreal atabStop)
{ tab = atabStop; }



#line 2 "../../include/QtGui/qtextoption.h"
#line 31 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtGui/qdrawutil.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qdrawutil.h"



















 




#line 1 "../../include/QtCore/qnamespace.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qdrawutil.h"
#line 1 "../../include/QtCore/qstring.h"
#line 27 "../../include/QtGui/../../src/gui/painting/qdrawutil.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QPainter;



class QPalette;
class QPoint;
class QColor;
class QBrush;
class QRect;
class QPixmap;





 void qDrawShadeLine(QPainter *p, int x1, int y1, int x2, int y2,
                              const QPalette &pal, bool sunken = true,
                              int lineWidth = 1, int midLineWidth = 0);

 void qDrawShadeLine(QPainter *p, const QPoint &p1, const QPoint &p2,
                              const QPalette &pal, bool sunken = true,
                              int lineWidth = 1, int midLineWidth = 0);

 void qDrawShadeRect(QPainter *p, int x, int y, int w, int h,
                              const QPalette &pal, bool sunken = false,
                              int lineWidth = 1, int midLineWidth = 0,
                              const QBrush *fill = 0);

 void qDrawShadeRect(QPainter *p, const QRect &r,
                              const QPalette &pal, bool sunken = false,
                              int lineWidth = 1, int midLineWidth = 0,
                              const QBrush *fill = 0);

 void qDrawShadePanel(QPainter *p, int x, int y, int w, int h,
                               const QPalette &pal, bool sunken = false,
                               int lineWidth = 1, const QBrush *fill = 0);

 void qDrawShadePanel(QPainter *p, const QRect &r,
                               const QPalette &pal, bool sunken = false,
                               int lineWidth = 1, const QBrush *fill = 0);

 void qDrawWinButton(QPainter *p, int x, int y, int w, int h,
                              const QPalette &pal, bool sunken = false,
                              const QBrush *fill = 0);

 void qDrawWinButton(QPainter *p, const QRect &r,
                              const QPalette &pal, bool sunken = false,
                              const QBrush *fill = 0);

 void qDrawWinPanel(QPainter *p, int x, int y, int w, int h,
                              const QPalette &pal, bool sunken = false,
                             const QBrush *fill = 0);

 void qDrawWinPanel(QPainter *p, const QRect &r,
                              const QPalette &pal, bool sunken = false,
                             const QBrush *fill = 0);

 void qDrawPlainRect(QPainter *p, int x, int y, int w, int h, const QColor &,
                              int lineWidth = 1, const QBrush *fill = 0);

 void qDrawPlainRect(QPainter *p, const QRect &r, const QColor &,
                              int lineWidth = 1, const QBrush *fill = 0);






  QRect qItemRect(QPainter *p, Qt::GUIStyle gs, int x, int y, int w, int h,
                          int flags, bool enabled,
                          const QPixmap *pixmap, const QString& text, int len=-1);

  void qDrawItem(QPainter *p, Qt::GUIStyle gs, int x, int y, int w, int h,
                         int flags, const QPalette &pal, bool enabled,
                         const QPixmap *pixmap, const QString& text,
                         int len=-1, const QColor* penColor = 0);

  void qDrawArrow(QPainter *p, Qt::ArrowType type, Qt::GUIStyle style, bool down,
                          int x, int y, int w, int h,
                          const QPalette &pal, bool enabled);




#line 2 "../../include/QtGui/qdrawutil.h"
#line 32 "../../include/QtGui/../../src/gui/painting/qpainter.h"

#line 1 "../../include/QtGui/qpolygon.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qpolygon.h"



















 




#line 1 "../../include/QtCore/qvector.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qpolygon.h"
#line 1 "../../include/QtCore/qpoint.h"
#line 27 "../../include/QtGui/../../src/gui/painting/qpolygon.h"
#line 1 "../../include/QtCore/qrect.h"
#line 28 "../../include/QtGui/../../src/gui/painting/qpolygon.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QMatrix;
class QRect;
class QVariant;

class  QPolygon : public QVector<QPoint>
{
public:
    inline QPolygon() {}
    inline ~QPolygon() {}
    inline QPolygon(int size);
    inline QPolygon(const QPolygon &a) : QVector<QPoint>(a) {}
    inline QPolygon(const QVector<QPoint> &v) : QVector<QPoint>(v) {}
    QPolygon(const QRect &r, bool closed=false);
    QPolygon(int nPoints, const int *points);
    operator QVariant() const;

    void translate(int dx, int dy);
    void translate(const QPoint &offset);
    QRect boundingRect() const;

    void point(int i, int *x, int *y) const;
    QPoint point(int i) const;
    void setPoint(int index, int x, int y);
    void setPoint(int index, const QPoint &p);
    void setPoints(int nPoints, const int *points);
    void setPoints(int nPoints, int firstx, int firsty, ...);
    void putPoints(int index, int nPoints, const int *points);
    void putPoints(int index, int nPoints, int firstx, int firsty, ...);
    void putPoints(int index, int nPoints, const QPolygon & from, int fromIndex=0);
};

inline QPolygon::QPolygon(int asize) : QVector<QPoint>(asize) {}


 QDebug operator<<(QDebug, const QPolygon &);




 

inline void QPolygon::setPoint(int index, const QPoint &pt)
{ (*this)[index] = pt; }

inline void QPolygon::setPoint(int index, int x, int y)
{ (*this)[index] = QPoint(x, y); }

inline QPoint QPolygon::point(int index) const
{ return at(index); }

inline void QPolygon::translate(const QPoint &offset)
{ translate(offset.x(), offset.y()); }

class QRectF;

class  QPolygonF : public QVector<QPointF>
{
public:
    inline QPolygonF() {}
    inline ~QPolygonF() {}
    inline QPolygonF(int size);
    inline QPolygonF(const QPolygonF &a) : QVector<QPointF>(a) {}
    inline QPolygonF(const QVector<QPointF> &v) : QVector<QPointF>(v) {}
    QPolygonF(const QRectF &r);
    QPolygonF(const QPolygon &a);

    inline void translate(qreal dx, qreal dy);
    void translate(const QPointF &offset);

    QPolygon toPolygon() const;

    bool isClosed() const { return !isEmpty() && first() == last(); }

    QRectF boundingRect() const;
};

inline QPolygonF::QPolygonF(int asize) : QVector<QPointF>(asize) {}


 QDebug operator<<(QDebug, const QPolygonF &);




 

 QDataStream &operator<<(QDataStream &stream, const QPolygonF &array);
 QDataStream &operator>>(QDataStream &stream, QPolygonF &array);


inline void QPolygonF::translate(qreal dx, qreal dy)
{ translate(QPointF(dx, dy)); }



#line 2 "../../include/QtGui/qpolygon.h"
#line 35 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtGui/qpen.h"
#line 36 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtGui/qbrush.h"
#line 37 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtGui/qmatrix.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qmatrix.h"



















 




#line 1 "../../include/QtGui/qpolygon.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qmatrix.h"
#line 1 "../../include/QtGui/qregion.h"
#line 27 "../../include/QtGui/../../src/gui/painting/qmatrix.h"
#line 1 "../../include/QtGui/qwindowdefs.h"
#line 28 "../../include/QtGui/../../src/gui/painting/qmatrix.h"
#line 1 "../../include/QtCore/qline.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qline.h"



















 




#line 1 "../../include/QtCore/qpoint.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qline.h"



typedef QtValidLicenseForCoreModule QtCoreModule;



 

class  QLine
{
public:
    inline QLine();
    inline QLine(const QPoint &pt1, const QPoint &pt2);
    inline QLine(int x1, int y1, int x2, int y2);

    inline bool isNull() const;

    inline QPoint p1() const;
    inline QPoint p2() const;

    inline int x1() const;
    inline int y1() const;

    inline int x2() const;
    inline int y2() const;

    inline int dx() const;
    inline int dy() const;

    inline void translate(const QPoint &p);
    inline void translate(int dx, int dy);

    inline bool operator==(const QLine &d) const;
    inline bool operator!=(const QLine &d) const { return !(*this == d); }

private:
    QPoint pt1, pt2;
};
template <> class QTypeInfo<QLine> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLine)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLine"; } };



 

inline QLine::QLine() { }

inline QLine::QLine(const QPoint &pt1_, const QPoint &pt2_) : pt1(pt1_), pt2(pt2_) { }

inline QLine::QLine(int x1pos, int y1pos, int x2pos, int y2pos) : pt1(QPoint(x1pos, y1pos)), pt2(QPoint(x2pos, y2pos)) { }

inline bool QLine::isNull() const
{
    return pt1 == pt2;
}

inline int QLine::x1() const
{
    return pt1.x();
}

inline int QLine::y1() const
{
    return pt1.y();
}

inline int QLine::x2() const
{
    return pt2.x();
}

inline int QLine::y2() const
{
    return pt2.y();
}

inline QPoint QLine::p1() const
{
    return pt1;
}

inline QPoint QLine::p2() const
{
    return pt2;
}

inline int QLine::dx() const
{
    return pt2.x() - pt1.x();
}

inline int QLine::dy() const
{
    return pt2.y() - pt1.y();
}

inline void QLine::translate(const QPoint &point)
{
    pt1 += point;
    pt2 += point;
}

inline void QLine::translate(int adx, int ady)
{
    this->translate(QPoint(adx, ady));
}

inline bool QLine::operator==(const QLine &d) const
{
    return pt1 == d.pt1 && pt2 == d.pt2;
}


 QDebug operator<<(QDebug d, const QLine &p);



 QDataStream &operator<<(QDataStream &, const QLine &);
 QDataStream &operator>>(QDataStream &, QLine &);




 
class  QLineF {
public:

    enum IntersectType { NoIntersection, BoundedIntersection, UnboundedIntersection };

    inline QLineF();
    inline QLineF(const QPointF &pt1, const QPointF &pt2);
    inline QLineF(qreal x1, qreal y1, qreal x2, qreal y2);
    inline QLineF(const QLine &line) : pt1(line.p1()), pt2(line.p2()) { }

    bool isNull() const;

    inline QPointF p1() const;
    inline QPointF p2() const;

    inline qreal x1() const;
    inline qreal y1() const;

    inline qreal x2() const;
    inline qreal y2() const;

    inline qreal dx() const;
    inline qreal dy() const;

    qreal length() const;
    void setLength(qreal len);

    QLineF unitVector() const;
    QLineF normalVector() const;

    IntersectType intersect(const QLineF &l, QPointF *intersectionPoint) const;

    qreal angle(const QLineF &l) const;

    QPointF pointAt(qreal t) const;
    inline void translate(const QPointF &p);
    inline void translate(qreal dx, qreal dy);

    inline bool operator==(const QLineF &d) const;
    inline bool operator!=(const QLineF &d) const { return !(*this == d); }

    QLine toLine() const;

private:
    QPointF pt1, pt2;
};
template <> class QTypeInfo<QLineF> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLineF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLineF"; } };



 

inline QLineF::QLineF()
{
}

inline QLineF::QLineF(const QPointF &apt1, const QPointF &apt2)
    : pt1(apt1), pt2(apt2)
{
}

inline QLineF::QLineF(qreal x1pos, qreal y1pos, qreal x2pos, qreal y2pos)
    : pt1(x1pos, y1pos), pt2(x2pos, y2pos)
{
}

inline qreal QLineF::x1() const
{
    return pt1.x();
}

inline qreal QLineF::y1() const
{
    return pt1.y();
}

inline qreal QLineF::x2() const
{
    return pt2.x();
}

inline qreal QLineF::y2() const
{
    return pt2.y();
}

inline QPointF QLineF::p1() const
{
    return pt1;
}

inline QPointF QLineF::p2() const
{
    return pt2;
}

inline qreal QLineF::dx() const
{
    return pt2.x() - pt1.x();
}

inline qreal QLineF::dy() const
{
    return pt2.y() - pt1.y();
}

inline QLineF QLineF::normalVector() const
{
    return QLineF(p1(), p1() + QPointF(dy(), -dx()));
}

inline void QLineF::translate(const QPointF &point)
{
    pt1 += point;
    pt2 += point;
}

inline void QLineF::translate(qreal adx, qreal ady)
{
    this->translate(QPointF(adx, ady));
}

inline void QLineF::setLength(qreal len)
{
    if (isNull())
        return;
    QLineF v = unitVector();
    pt2 = QPointF(pt1.x() + v.dx() * len, pt1.y() + v.dy() * len);
}

inline QPointF QLineF::pointAt(qreal t) const
{
    qreal vx = pt2.x() - pt1.x();
    qreal vy = pt2.y() - pt1.y();
    return QPointF(pt1.x() + vx * t, pt1.y() + vy * t);
}

inline QLine QLineF::toLine() const
{
    return QLine(pt1.toPoint(), pt2.toPoint());
}

inline bool QLineF::operator==(const QLineF &d) const
{
    return pt1 == d.pt1 && pt2 == d.pt2;
}


 QDebug operator<<(QDebug d, const QLineF &p);



 QDataStream &operator<<(QDataStream &, const QLineF &);
 QDataStream &operator>>(QDataStream &, QLineF &);




#line 2 "../../include/QtCore/qline.h"
#line 29 "../../include/QtGui/../../src/gui/painting/qmatrix.h"
#line 1 "../../include/QtCore/qpoint.h"
#line 30 "../../include/QtGui/../../src/gui/painting/qmatrix.h"
#line 1 "../../include/QtCore/qrect.h"
#line 31 "../../include/QtGui/../../src/gui/painting/qmatrix.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QPainterPath;

class  QMatrix 
{
public:
    QMatrix();
    QMatrix(qreal m11, qreal m12, qreal m21, qreal m22,
            qreal dx, qreal dy);
    QMatrix(const QMatrix &matrix);

    void setMatrix(qreal m11, qreal m12, qreal m21, qreal m22,
                   qreal dx, qreal dy);

    qreal m11() const { return _m11; }
    qreal m12() const { return _m12; }
    qreal m21() const { return _m21; }
    qreal m22() const { return _m22; }
    qreal dx() const { return _dx; }
    qreal dy() const { return _dy; }

    void map(int x, int y, int *tx, int *ty) const;
    void map(qreal x, qreal y, qreal *tx, qreal *ty) const;
    QRect mapRect(const QRect &) const;
    QRectF mapRect(const QRectF &) const;

    QPoint map(const QPoint &p) const;
    QPointF map(const QPointF&p) const;
    QLine map(const QLine &l) const;
    QLineF map(const QLineF &l) const;
    QPolygonF map(const QPolygonF &a) const;
    QPolygon map(const QPolygon &a) const;
    QRegion map(const QRegion &r) const;
    QPainterPath map(const QPainterPath &p) const;
    QPolygon mapToPolygon(const QRect &r) const;

    void reset();
    inline bool isIdentity() const;

    QMatrix &translate(qreal dx, qreal dy);
    QMatrix &scale(qreal sx, qreal sy);
    QMatrix &shear(qreal sh, qreal sv);
    QMatrix &rotate(qreal a);

    bool isInvertible() const { return !qFuzzyCompare(_m11*_m22 - _m12*_m21, 0); }
    qreal det() const { return _m11*_m22 - _m12*_m21; }

    QMatrix inverted(bool *invertible = 0) const;

    bool operator==(const QMatrix &) const;
    bool operator!=(const QMatrix &) const;

    QMatrix &operator*=(const QMatrix &);
    QMatrix operator*(const QMatrix &o) const;

    QMatrix &operator=(const QMatrix &);


    inline  QMatrix invert(bool *invertible=0) const { return inverted(invertible); }
    inline  QRect map(const QRect &r) const { return mapRect(r); }
     QRegion mapToRegion(const QRect &r) const;


private:
    qreal _m11, _m12;
    qreal _m21, _m22;
    qreal _dx, _dy;
};
template <> class QTypeInfo<QMatrix> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QMatrix)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QMatrix"; } };


inline  QPoint operator*(const QPoint &p, const QMatrix &m)
{ return m.map(p); }
inline  QPointF operator*(const QPointF &p, const QMatrix &m)
{ return m.map(p); }
inline  QLineF operator*(const QLineF &l, const QMatrix &m)
{ return m.map(l); }
inline  QLine operator*(const QLine &l, const QMatrix &m)
{ return m.map(l); }
inline  QPolygon operator *(const QPolygon &a, const QMatrix &m)
{ return m.map(a); }
inline  QPolygonF operator *(const QPolygonF &a, const QMatrix &m)
{ return m.map(a); }
inline  QRegion operator *(const QRegion &r, const QMatrix &m)
{ return m.map(r); }
 QPainterPath operator *(const QPainterPath &p, const QMatrix &m);

inline bool QMatrix::isIdentity() const
{
    return qFuzzyCompare(_m11, 1) && qFuzzyCompare(_m22, 1) && qFuzzyCompare(_m12, 0)
           && qFuzzyCompare(_m21, 0) && qFuzzyCompare(_dx, 0) && qFuzzyCompare(_dy, 0);
}



 

 QDataStream &operator<<(QDataStream &, const QMatrix &);
 QDataStream &operator>>(QDataStream &, QMatrix &);


 QDebug operator<<(QDebug, const QMatrix &);


#line 1 "../../include/QtGui/qwmatrix.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qwmatrix.h"



















 




#line 1 "../../include/QtGui/qmatrix.h"
#line 1 "../../include/QtGui/../../src/gui/painting/qmatrix.h"



















 

#line 2 "../../include/QtGui/qmatrix.h"
#line 26 "../../include/QtGui/../../src/gui/painting/qwmatrix.h"



typedef QtValidLicenseForGuiModule QtGuiModule;


typedef QMatrix QWMatrix;




#line 2 "../../include/QtGui/qwmatrix.h"
#line 141 "../../include/QtGui/../../src/gui/painting/qmatrix.h"




#line 2 "../../include/QtGui/qmatrix.h"
#line 38 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtGui/qfontinfo.h"
#line 1 "../../include/QtGui/../../src/gui/text/qfontinfo.h"



















 




#line 1 "../../include/QtGui/qfont.h"
#line 26 "../../include/QtGui/../../src/gui/text/qfontinfo.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class  QFontInfo
{
public:
    QFontInfo(const QFont &);
    QFontInfo(const QFontInfo &);
    ~QFontInfo();

    QFontInfo &operator=(const QFontInfo &);

    QString family() const;
    int pixelSize() const;
    int pointSize() const;
    qreal pointSizeF() const;
    bool italic() const;
    QFont::Style style() const;
    int weight() const;
    inline bool bold() const { return weight() > QFont::Normal; }
    bool underline() const;
    bool overline() const;
    bool strikeOut() const;
    bool fixedPitch() const;
    QFont::StyleHint styleHint() const;
    bool rawMode() const;

    bool exactMatch() const;

private:
    QFontPrivate *d;
};



#line 2 "../../include/QtGui/qfontinfo.h"
#line 39 "../../include/QtGui/../../src/gui/painting/qpainter.h"
#line 1 "../../include/QtGui/qfontmetrics.h"
#line 1 "../../include/QtGui/../../src/gui/text/qfontmetrics.h"



















 




#line 1 "../../include/QtGui/qfont.h"
#line 26 "../../include/QtGui/../../src/gui/text/qfontmetrics.h"
#line 1 "../../include/QtCore/qrect.h"
#line 28 "../../include/QtGui/../../src/gui/text/qfontmetrics.h"




typedef QtValidLicenseForGuiModule QtGuiModule;





class QTextCodec;
class QRect;


class  QFontMetrics
{
public:
    QFontMetrics(const QFont &);
    QFontMetrics(const QFont &, QPaintDevice *pd);
    QFontMetrics(const QFontMetrics &);
    ~QFontMetrics();

    QFontMetrics &operator=(const QFontMetrics &);

    int ascent() const;
    int descent() const;
    int height() const;
    int leading() const;
    int lineSpacing() const;
    int minLeftBearing() const;
    int minRightBearing() const;
    int maxWidth() const;

    int xHeight() const;

    bool inFont(QChar) const;

    int leftBearing(QChar) const;
    int rightBearing(QChar) const;
    int width(const QString &, int len = -1) const;

    int width(QChar) const;
    int charWidth(const QString &str, int pos) const;

    QRect boundingRect(QChar) const;

    QRect boundingRect(const QString &text) const;
    QRect boundingRect(const QRect &r, int flags, const QString &text, int tabstops=0, int *tabarray=0) const;
    inline QRect boundingRect(int x, int y, int w, int h, int flags, const QString &text,
                              int tabstops=0, int *tabarray=0) const
        { return boundingRect(QRect(x, y, w, h), flags, text, tabstops, tabarray); }
    QSize size(int flags, const QString& str, int tabstops=0, int *tabarray=0) const;

    int underlinePos() const;
    int overlinePos() const;
    int strikeOutPos() const;
    int lineWidth() const;

    bool operator==(const QFontMetrics &other); 
    bool operator==(const QFontMetrics &other) const;
    inline bool operator !=(const QFontMetrics &other) { return !operator==(other); }


    inline QRect boundingRect(const QString &text, int len) const
        { return boundingRect(text.left(len)); }
    inline QRect boundingRect(int x, int y, int w, int h, int flags, const QString& str, int len,
                              int tabstops=0, int *tabarray=0) const
        { return boundingRect(QRect(x, y, w, h), flags, str.left(len), tabstops, tabarray); }
    inline QSize size(int flags, const QString& str, int len, int tabstops=0, int *tabarray=0) const
        { return size(flags, str.left(len), tabstops, tabarray); }

private:




    QFontPrivate *d;
};


class  QFontMetricsF
{
public:
    QFontMetricsF(const QFont &);
    QFontMetricsF(const QFont &, QPaintDevice *pd);

    QFontMetricsF(const QFontMetricsF &);
    ~QFontMetricsF();

    QFontMetricsF &operator=(const QFontMetricsF &);


    qreal ascent() const;
    qreal descent() const;
    qreal height() const;
    qreal leading() const;
    qreal lineSpacing() const;
    qreal minLeftBearing() const;
    qreal minRightBearing() const;
    qreal maxWidth() const;

    qreal xHeight() const;

    bool inFont(QChar) const;

    qreal leftBearing(QChar) const;
    qreal rightBearing(QChar) const;
    qreal width(const QString &string) const;

    qreal width(QChar) const;

    QRectF boundingRect(const QString &string) const;
    QRectF boundingRect(QChar) const;
    QRectF boundingRect(const QRectF &r, int flags, const QString& string, int tabstops=0, int *tabarray=0) const;
    QSizeF size(int flags, const QString& str, int tabstops=0, int *tabarray=0) const;

    qreal underlinePos() const;
    qreal overlinePos() const;
    qreal strikeOutPos() const;
    qreal lineWidth() const;

    bool operator==(const QFontMetricsF &other); 
    bool operator==(const QFontMetricsF &other) const;
    inline bool operator !=(const QFontMetricsF &other) { return !operator==(other); } 
    inline bool operator !=(const QFontMetricsF &other) const { return !operator==(other); }

private:
    QFontPrivate *d;
};



#line 2 "../../include/QtGui/qfontmetrics.h"
#line 40 "../../include/QtGui/../../src/gui/painting/qpainter.h"




typedef QtValidLicenseForGuiModule QtGuiModule;

class QBrush;
class QFontInfo;
class QFontMetrics;
class QPaintDevice;
class QPainterPath;
class QPainterPrivate;
class QPen;
class QPolygon;
class QTextItem;
class QMatrix;

class  QPainter
{
    inline QPainterPrivate* d_func() { return reinterpret_cast<QPainterPrivate * >(d_ptr); } inline const QPainterPrivate* d_func() const { return reinterpret_cast<const QPainterPrivate * >(d_ptr); } friend class QPainterPrivate;

public:
    enum RenderHint {
        Antialiasing = 0x01,
        TextAntialiasing = 0x02,
        SmoothPixmapTransform = 0x04
    };

    typedef QFlags<RenderHint> RenderHints;

    QPainter();
    explicit QPainter(QPaintDevice *);
    ~QPainter();

    QPaintDevice *device() const;

    bool begin(QPaintDevice *);
    bool end();
    bool isActive() const;

    void initFrom(const QWidget *widget);

    enum CompositionMode {
        CompositionMode_SourceOver,
        CompositionMode_DestinationOver,
        CompositionMode_Clear,
        CompositionMode_Source,
        CompositionMode_Destination,
        CompositionMode_SourceIn,
        CompositionMode_DestinationIn,
        CompositionMode_SourceOut,
        CompositionMode_DestinationOut,
        CompositionMode_SourceAtop,
        CompositionMode_DestinationAtop,
        CompositionMode_Xor
    };
    void setCompositionMode(CompositionMode mode);
    CompositionMode compositionMode() const;

    const QFont &font() const;
    void setFont(const QFont &f);

    QFontMetrics fontMetrics() const;
    QFontInfo fontInfo() const;

    void setPen(const QColor &color);
    void setPen(const QPen &pen);
    void setPen(Qt::PenStyle style);
    const QPen &pen() const;

    void setBrush(const QBrush &brush);
    void setBrush(Qt::BrushStyle style);
    const QBrush &brush() const;

    
    void setBackgroundMode(Qt::BGMode mode);
    Qt::BGMode backgroundMode() const;

    QPoint brushOrigin() const;
    inline void setBrushOrigin(int x, int y);
    inline void setBrushOrigin(const QPoint &);
    void setBrushOrigin(const QPointF &);

    void setBackground(const QBrush &bg);
    const QBrush &background() const;

    
    QRegion clipRegion() const;
    QPainterPath clipPath() const;

    void setClipRect(const QRectF &, Qt::ClipOperation op = Qt::ReplaceClip);
    inline void setClipRect(const QRect &, Qt::ClipOperation op = Qt::ReplaceClip);
    inline void setClipRect(int x, int y, int w, int h, Qt::ClipOperation op = Qt::ReplaceClip);

    void setClipRegion(const QRegion &, Qt::ClipOperation op = Qt::ReplaceClip);

    void setClipPath(const QPainterPath &path, Qt::ClipOperation op = Qt::ReplaceClip);

    void setClipping(bool enable);
    bool hasClipping() const;

    void save();
    void restore();

    
    void setMatrix(const QMatrix &matrix, bool combine = false);
    const QMatrix &matrix() const;
    const QMatrix &deviceMatrix() const;
    void resetMatrix();

    void setMatrixEnabled(bool enabled);
    bool matrixEnabled() const;

    void scale(qreal sx, qreal sy);
    void shear(qreal sh, qreal sv);
    void rotate(qreal a);

    void translate(const QPointF &offset);
    inline void translate(const QPoint &offset);
    inline void translate(qreal dx, qreal dy);

    QRect window() const;
    void setWindow(const QRect &window);
    inline void setWindow(int x, int y, int w, int h);

    QRect viewport() const;
    void setViewport(const QRect &viewport);
    inline void setViewport(int x, int y, int w, int h);

    void setViewTransformEnabled(bool enable);
    bool viewTransformEnabled() const;

    
    void strokePath(const QPainterPath &path, const QPen &pen);
    void fillPath(const QPainterPath &path, const QBrush &brush);
    void drawPath(const QPainterPath &path);

    inline void drawPoint(const QPointF &pt);
    inline void drawPoint(const QPoint &p);
    inline void drawPoint(int x, int y);

    void drawPoints(const QPointF *points, int pointCount);
    inline void drawPoints(const QPolygonF &points);
    void drawPoints(const QPoint *points, int pointCount);
    inline void drawPoints(const QPolygon &points);

    inline void drawLine(const QLineF &line);
    inline void drawLine(const QLine &line);
    inline void drawLine(int x1, int y1, int x2, int y2);
    inline void drawLine(const QPoint &p1, const QPoint &p2);
    inline void drawLine(const QPointF &p1, const QPointF &p2);

    void drawLines(const QLineF *lines, int lineCount);
    inline void drawLines(const QVector<QLineF> &lines);
    void drawLines(const QPointF *pointPairs, int lineCount);
    inline void drawLines(const QVector<QPointF> &pointPairs);
    void drawLines(const QLine *lines, int lineCount);
    inline void drawLines(const QVector<QLine> &lines);
    void drawLines(const QPoint *pointPairs, int lineCount);
    inline void drawLines(const QVector<QPoint> &pointPairs);

    inline void drawRect(const QRectF &rect);
    inline void drawRect(int x1, int y1, int w, int h);
    inline void drawRect(const QRect &rect);

    void drawRects(const QRectF *rects, int rectCount);
    inline void drawRects(const QVector<QRectF> &rectangles);
    void drawRects(const QRect *rects, int rectCount);
    inline void drawRects(const QVector<QRect> &rectangles);

    void drawEllipse(const QRectF &r);
    void drawEllipse(const QRect &r);
    inline void drawEllipse(int x, int y, int w, int h);

    void drawPolyline(const QPointF *points, int pointCount);
    inline void drawPolyline(const QPolygonF &polyline);
    void drawPolyline(const QPoint *points, int pointCount);
    inline void drawPolyline(const QPolygon &polygon);

    void drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill);
    inline void drawPolygon(const QPolygonF &polygon, Qt::FillRule fillRule = Qt::OddEvenFill);
    void drawPolygon(const QPoint *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill);
    inline void drawPolygon(const QPolygon &polygon, Qt::FillRule fillRule = Qt::OddEvenFill);

    void drawConvexPolygon(const QPointF *points, int pointCount);
    inline void drawConvexPolygon(const QPolygonF &polygon);
    void drawConvexPolygon(const QPoint *points, int pointCount);
    inline void drawConvexPolygon(const QPolygon &polygon);

    void drawArc(const QRectF &rect, int a, int alen);
    inline void drawArc(const QRect &, int a, int alen);
    inline void drawArc(int x, int y, int w, int h, int a, int alen);

    void drawPie(const QRectF &rect, int a, int alen);
    inline void drawPie(int x, int y, int w, int h, int a, int alen);
    inline void drawPie(const QRect &, int a, int alen);

    void drawChord(const QRectF &rect, int a, int alen);
    inline void drawChord(int x, int y, int w, int h, int a, int alen);
    inline void drawChord(const QRect &, int a, int alen);

    void drawRoundRect(const QRectF &r, int xround = 25, int yround = 25);
    inline void drawRoundRect(int x, int y, int w, int h, int = 25, int = 25);
    inline void drawRoundRect(const QRect &r, int xround = 25, int yround = 25);

    void drawTiledPixmap(const QRectF &rect, const QPixmap &pm, const QPointF &offset = QPointF());
    inline void drawTiledPixmap(int x, int y, int w, int h, const QPixmap &, int sx=0, int sy=0);
    inline void drawTiledPixmap(const QRect &, const QPixmap &, const QPoint & = QPoint());

    void drawPicture(const QPointF &p, const QPicture &picture);
    inline void drawPicture(int x, int y, const QPicture &picture);
    inline void drawPicture(const QPoint &p, const QPicture &picture);


    void drawPixmap(const QRectF &targetRect, const QPixmap &pixmap, const QRectF &sourceRect);
    inline void drawPixmap(const QRect &targetRect, const QPixmap &pixmap, const QRect &sourceRect);
    inline void drawPixmap(int x, int y, int w, int h, const QPixmap &pm,
                           int sx, int sy, int sw, int sh);
    inline void drawPixmap(int x, int y, const QPixmap &pm,
                           int sx, int sy, int sw, int sh);
    inline void drawPixmap(const QPointF &p, const QPixmap &pm, const QRectF &sr);
    inline void drawPixmap(const QPoint &p, const QPixmap &pm, const QRect &sr);
    inline void drawPixmap(const QPointF &p, const QPixmap &pm);
    inline void drawPixmap(const QPoint &p, const QPixmap &pm);
    inline void drawPixmap(int x, int y, const QPixmap &pm);
    inline void drawPixmap(const QRect &r, const QPixmap &pm);
    inline void drawPixmap(int x, int y, int w, int h, const QPixmap &pm);

    void drawImage(const QRectF &targetRect, const QImage &image, const QRectF &sourceRect,
                   Qt::ImageConversionFlags flags = Qt::AutoColor);
    inline void drawImage(const QRect &targetRect, const QImage &image, const QRect &sourceRect,
                          Qt::ImageConversionFlags flags = Qt::AutoColor);
    inline void drawImage(const QPointF &p, const QImage &image, const QRectF &sr,
                          Qt::ImageConversionFlags flags = Qt::AutoColor);
    inline void drawImage(const QPoint &p, const QImage &image, const QRect &sr,
                          Qt::ImageConversionFlags flags = Qt::AutoColor);
    inline void drawImage(const QRectF &r, const QImage &image);
    inline void drawImage(const QRect &r, const QImage &image);
    inline void drawImage(const QPointF &p, const QImage &image);
    inline void drawImage(const QPoint &p, const QImage &image);
    inline void drawImage(int x, int y, const QImage &image, int sx = 0, int sy = 0,
                          int sw = -1, int sh = -1, Qt::ImageConversionFlags flags = Qt::AutoColor);

    void setLayoutDirection(Qt::LayoutDirection direction);
    Qt::LayoutDirection layoutDirection() const;

    void drawText(const QPointF &p, const QString &s);
    inline void drawText(const QPoint &p, const QString &s);
    inline void drawText(int x, int y, const QString &s);

    void drawText(const QRectF &r, int flags, const QString &text, QRectF *br=0);
    void drawText(const QRect &r, int flags, const QString &text, QRect *br=0);
    inline void drawText(int x, int y, int w, int h, int flags, const QString &text, QRect *br=0);

    void drawText(const QRectF &r, const QString &text, const QTextOption &o = QTextOption());

    QRectF boundingRect(const QRectF &rect, int flags, const QString &text);
    QRect boundingRect(const QRect &rect, int flags, const QString &text);
    inline QRect boundingRect(int x, int y, int w, int h, int flags, const QString &text);

    QRectF boundingRect(const QRectF &rect, const QString &text, const QTextOption &o = QTextOption());

    void drawTextItem(const QPointF &p, const QTextItem &ti);
    inline void drawTextItem(int x, int y, const QTextItem &ti);
    inline void drawTextItem(const QPoint &p, const QTextItem &ti);

    void fillRect(const QRectF &, const QBrush &);
    inline void fillRect(int x, int y, int w, int h, const QBrush &);
    void fillRect(const QRect &, const QBrush &);

    void eraseRect(const QRectF &);
    inline void eraseRect(int x, int y, int w, int h);
    inline void eraseRect(const QRect &);

    void setRenderHint(RenderHint hint, bool on = true);
    RenderHints renderHints() const;

    QPaintEngine *paintEngine() const;

    static void setRedirected(const QPaintDevice *device, QPaintDevice *replacement,
                              const QPoint& offset = QPoint());
    static QPaintDevice *redirected(const QPaintDevice *device, QPoint *offset = 0);
    static void restoreRedirected(const QPaintDevice *device);



    inline  void setBackgroundColor(const QColor &color) { setBackground(color); }
    inline  const QColor &backgroundColor() const { return background().color(); }

    inline  void drawText(int x, int y, const QString &s, int pos, int len)
        { drawText(x, y, s.mid(pos, len)); }
    inline  void drawText(const QPoint &p, const QString &s, int pos, int len)
        { drawText(p, s.mid(pos, len)); }
    inline  void drawText(int x, int y, const QString &s, int len)
        { drawText(x, y, s.left(len)); }
    inline  void drawText(const QPoint &p, const QString &s, int len)
        { drawText(p, s.left(len)); }
    inline  void drawText(const QRect &r, int flags, const QString &str, int len, QRect *br=0)
        { drawText(r, flags, str.left(len), br); }
    inline  void drawText(int x, int y, int w, int h, int flags, const QString &text, int len, QRect *br=0)
        { drawText(QRect(x, y, w, h), flags, text.left(len), br); }
    inline  QRect boundingRect(const QRect &rect, int flags, const QString &text, int len)
        { return boundingRect(rect, flags, text.left(len)); }
    inline  QRect boundingRect(int x, int y, int w, int h, int flags, const QString &text, int len)
        { return boundingRect(QRect(x, y, w, h), flags, text.left(len)); }

    inline  bool begin(QPaintDevice *pdev, const QWidget *init)
        { bool ret = begin(pdev); initFrom(init); return ret; }
     void drawPoints(const QPolygon &pa, int index, int npoints = -1)
    { drawPoints(pa.constData() + index, npoints == -1 ? pa.size() - index : npoints); }

     void drawCubicBezier(const QPolygon &pa, int index = 0);

     void drawLineSegments(const QPolygon &points, int index = 0, int nlines = -1);

    inline  void drawPolyline(const QPolygon &pa, int index, int npoints = -1)
    { drawPolyline(pa.constData() + index, npoints == -1 ? pa.size() - index : npoints); }

    inline  void drawPolygon(const QPolygon &pa, bool winding, int index = 0, int npoints = -1)
    { drawPolygon(pa.constData() + index, npoints == -1 ? pa.size() - index : npoints,
                  winding ? Qt::WindingFill : Qt::OddEvenFill); }

    inline  void drawPolygon(const QPolygonF &polygon, bool winding, int index = 0,
                                      int npoints = -1)
    { drawPolygon(polygon.constData() + index, npoints == -1 ? polygon.size() - index : npoints,
                  winding ? Qt::WindingFill : Qt::OddEvenFill); }

    inline  void drawConvexPolygon(const QPolygonF &polygon, int index, int npoints = -1)
    { drawConvexPolygon(polygon.constData() + index, npoints == -1 ? polygon.size() - index : npoints); }
    inline  void drawConvexPolygon(const QPolygon &pa, int index, int npoints = -1)
    { drawConvexPolygon(pa.constData() + index, npoints == -1 ? pa.size() - index : npoints); }

    static inline  void redirect(QPaintDevice *pdev, QPaintDevice *replacement)
    { setRedirected(pdev, replacement); }
    static inline  QPaintDevice *redirect(QPaintDevice *pdev)
    { return const_cast<QPaintDevice*>(redirected(pdev)); }

    inline  void setWorldMatrix(const QMatrix &wm, bool combine=false) { setMatrix(wm, combine); }
    inline  const QMatrix &worldMatrix() const { return matrix(); }
    inline  void setWorldXForm(bool enabled) { setMatrixEnabled(enabled); }
    inline  bool hasWorldXForm() const { return matrixEnabled(); }
    inline  void resetXForm() { resetMatrix(); }

    inline  void setViewXForm(bool enabled) { setViewTransformEnabled(enabled); }
    inline  bool hasViewXForm() const { return viewTransformEnabled(); }

     void map(int x, int y, int *rx, int *ry) const;
     QPoint xForm(const QPoint &) const; 
     QRect xForm(const QRect &) const;
     QPolygon xForm(const QPolygon &) const;
     QPolygon xForm(const QPolygon &, int index, int npoints) const;
     QPoint xFormDev(const QPoint &) const; 
     QRect xFormDev(const QRect &) const;
     QPolygon xFormDev(const QPolygon &) const;
     QPolygon xFormDev(const QPolygon &, int index, int npoints) const;
     qreal translationX() const;
     qreal translationY() const;


private:
    friend class Q3Painter;
    friend void qt_format_text(const QFont &font, const QRectF &_r, int tf, const QString& str,
                               QRectF *brect, int tabstops, int* tabarray, int tabarraylen,
                               QPainter *painter);

    QPainterPrivate *d_ptr;

    friend class QFontEngine;
    friend class QFontEngineBox;
    friend class QFontEngineFT;
    friend class QFontEngineMac;
    friend class QFontEngineWin;
    friend class QFontEngineXLFD;
    friend class QWSManager;
    friend class QPaintEngine;
    friend class QX11PaintEngine;
    friend class QX11PaintEnginePrivate;
    friend class QWin32PaintEngine;
    friend class QWin32PaintEnginePrivate;
};

inline QFlags<QPainter::RenderHints::enum_type> operator|(QPainter::RenderHints::enum_type f1, QPainter::RenderHints::enum_type f2) { return QFlags<QPainter::RenderHints::enum_type>(f1) | f2; } inline QFlags<QPainter::RenderHints::enum_type> operator|(QPainter::RenderHints::enum_type f1, QFlags<QPainter::RenderHints::enum_type> f2) { return f2 | f1; }




inline void QPainter::drawLine(const QLineF &l)
{
    drawLines(&l, 1);
}

inline void QPainter::drawLine(const QLine &line)
{
    drawLines(&line, 1);
}

inline void QPainter::drawLine(int x1, int y1, int x2, int y2)
{
    QLine l(x1, y1, x2, y2);
    drawLines(&l, 1);
}

inline void QPainter::drawLine(const QPoint &p1, const QPoint &p2)
{
    QLine l(p1, p2);
    drawLines(&l, 1);
}

inline void QPainter::drawLine(const QPointF &p1, const QPointF &p2)
{
    drawLine(QLineF(p1, p2));
}

inline void QPainter::drawLines(const QVector<QLineF> &lines)
{
    drawLines(lines.constData(), lines.size());
}

inline void QPainter::drawLines(const QVector<QLine> &lines)
{
    drawLines(lines.constData(), lines.size());
}

inline void QPainter::drawLines(const QVector<QPointF> &pointPairs)
{
    drawLines(pointPairs.constData(), pointPairs.size() / 2);
}

inline void QPainter::drawLines(const QVector<QPoint> &pointPairs)
{
    drawLines(pointPairs.constData(), pointPairs.size() / 2);
}

inline void QPainter::drawPolyline(const QPolygonF &polyline)
{
    drawPolyline(polyline.constData(), polyline.size());
}

inline void QPainter::drawPolyline(const QPolygon &polyline)
{
    drawPolyline(polyline.constData(), polyline.size());
}

inline void QPainter::drawPolygon(const QPolygonF &polygon, Qt::FillRule fillRule)
{
    drawPolygon(polygon.constData(), polygon.size(), fillRule);
}

inline void QPainter::drawPolygon(const QPolygon &polygon, Qt::FillRule fillRule)
{
    drawPolygon(polygon.constData(), polygon.size(), fillRule);
}

inline void QPainter::drawConvexPolygon(const QPolygonF &poly)
{
    drawConvexPolygon(poly.constData(), poly.size());
}

inline void QPainter::drawConvexPolygon(const QPolygon &poly)
{
    drawConvexPolygon(poly.constData(), poly.size());
}

inline void QPainter::drawRect(const QRectF &rect)
{
    drawRects(&rect, 1);
}

inline void QPainter::drawRect(int x, int y, int w, int h)
{
    QRect r(x, y, w, h);
    drawRects(&r, 1);
}

inline void QPainter::drawRect(const QRect &r)
{
    drawRects(&r, 1);
}

inline void QPainter::drawRects(const QVector<QRectF> &rects)
{
    drawRects(rects.constData(), rects.size());
}

inline void QPainter::drawRects(const QVector<QRect> &rects)
{
    drawRects(rects.constData(), rects.size());
}

inline void QPainter::drawPoint(const QPointF &p)
{
    drawPoints(&p, 1);
}

inline void QPainter::drawPoint(int x, int y)
{
    QPoint p(x, y);
    drawPoints(&p, 1);
}

inline void QPainter::drawPoint(const QPoint &p)
{
    drawPoints(&p, 1);
}

inline void QPainter::drawPoints(const QPolygonF &points)
{
    drawPoints(points.constData(), points.size());
}

inline void QPainter::drawPoints(const QPolygon &points)
{
    drawPoints(points.constData(), points.size());
}

inline void QPainter::drawRoundRect(int x, int y, int w, int h, int xRnd, int yRnd)
{
    drawRoundRect(QRectF(x, y, w, h), xRnd, yRnd);
}

inline void QPainter::drawRoundRect(const QRect &rect, int xRnd, int yRnd)
{
    drawRoundRect(QRectF(rect), xRnd, yRnd);
}

inline void QPainter::drawEllipse(int x, int y, int w, int h)
{
    drawEllipse(QRect(x, y, w, h));
}

inline void QPainter::drawArc(const QRect &r, int a, int alen)
{
    drawArc(QRectF(r), a, alen);
}

inline void QPainter::drawArc(int x, int y, int w, int h, int a, int alen)
{
    drawArc(QRectF(x, y, w, h), a, alen);
}

inline void QPainter::drawPie(const QRect &rect, int a, int alen)
{
    drawPie(QRectF(rect), a, alen);
}

inline void QPainter::drawPie(int x, int y, int w, int h, int a, int alen)
{
    drawPie(QRectF(x, y, w, h), a, alen);
}

inline void QPainter::drawChord(const QRect &rect, int a, int alen)
{
    drawChord(QRectF(rect), a, alen);
}

inline void QPainter::drawChord(int x, int y, int w, int h, int a, int alen)
{
    drawChord(QRectF(x, y, w, h), a, alen);
}

inline void QPainter::setClipRect(int x, int y, int w, int h, Qt::ClipOperation op)
{
    setClipRect(QRectF(x, y, w, h), op);
}

inline void QPainter::setClipRect(const QRect &rect, Qt::ClipOperation op)
{
    setClipRect(QRectF(rect), op);
}

inline void QPainter::eraseRect(const QRect &rect)
{
    eraseRect(QRectF(rect));
}

inline void QPainter::eraseRect(int x, int y, int w, int h)
{
    eraseRect(QRectF(x, y, w, h));
}

inline void QPainter::fillRect(int x, int y, int w, int h, const QBrush &b)
{
    fillRect(QRect(x, y, w, h), b);
}

inline void QPainter::setBrushOrigin(int x, int y)
{
    setBrushOrigin(QPoint(x, y));
}

inline void QPainter::setBrushOrigin(const QPoint &p)
{
    setBrushOrigin(QPointF(p));
}

inline void QPainter::drawTiledPixmap(const QRect &rect, const QPixmap &pm, const QPoint &offset)
{
    drawTiledPixmap(QRectF(rect), pm, QPointF(offset));
}

inline void QPainter::drawTiledPixmap(int x, int y, int w, int h, const QPixmap &pm, int sx, int sy)
{
    drawTiledPixmap(QRectF(x, y, w, h), pm, QPointF(sx, sy));
}

inline void QPainter::drawPixmap(const QRect &targetRect, const QPixmap &pixmap, const QRect &sourceRect)
{
    drawPixmap(QRectF(targetRect), pixmap, QRectF(sourceRect));
}

inline void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
{
    drawPixmap(QRectF(p.x(), p.y(), -1, -1), pm, QRectF());
}

inline void QPainter::drawPixmap(const QPoint &p, const QPixmap &pm)
{
    drawPixmap(QRectF(p.x(), p.y(), -1, -1), pm, QRectF());
}

inline void QPainter::drawPixmap(const QRect &r, const QPixmap &pm)
{
    drawPixmap(QRectF(r), pm, QRectF());
}

inline void QPainter::drawPixmap(int x, int y, const QPixmap &pm)
{
    drawPixmap(QRectF(x, y, -1, -1), pm, QRectF());
}

inline void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pm)
{
    drawPixmap(QRectF(x, y, w, h), pm, QRectF());
}

inline void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pm,
                                 int sx, int sy, int sw, int sh)
{
    drawPixmap(QRectF(x, y, w, h), pm, QRectF(sx, sy, sw, sh));
}

inline void QPainter::drawPixmap(int x, int y, const QPixmap &pm,
                                 int sx, int sy, int sw, int sh)
{
    drawPixmap(QRectF(x, y, -1, -1), pm, QRectF(sx, sy, sw, sh));
}

inline void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm, const QRectF &sr)
{
    drawPixmap(QRectF(p.x(), p.y(), -1, -1), pm, sr);
}

inline void QPainter::drawPixmap(const QPoint &p, const QPixmap &pm, const QRect &sr)
{
    drawPixmap(QRectF(p.x(), p.y(), -1, -1), pm, sr);
}

inline void QPainter::drawTextItem(int x, int y, const QTextItem &ti)
{
    drawTextItem(QPointF(x, y), ti);
}

inline void QPainter::drawImage(const QRect &targetRect, const QImage &image, const QRect &sourceRect,
                                Qt::ImageConversionFlags flags)
{
    drawImage(QRectF(targetRect), image, QRectF(sourceRect), flags);
}

inline void QPainter::drawImage(const QPointF &p, const QImage &image, const QRectF &sr,
                                Qt::ImageConversionFlags flags)
{
    drawImage(QRectF(p.x(), p.y(), -1, -1), image, sr, flags);
}

inline void QPainter::drawImage(const QPoint &p, const QImage &image, const QRect &sr,
                                Qt::ImageConversionFlags flags)
{
    drawImage(QRect(p.x(), p.y(), -1, -1), image, sr, flags);
}


inline void QPainter::drawImage(const QRectF &r, const QImage &image)
{
    drawImage(r, image, QRect(0, 0, image.width(), image.height()));
}

inline void QPainter::drawImage(const QRect &r, const QImage &image)
{
    drawImage(r, image, QRectF(0, 0, image.width(), image.height()));
}

inline void QPainter::drawImage(const QPointF &p, const QImage &image)
{
    drawImage(QRectF(p.x(), p.y(), -1, -1), image, QRectF(0, 0, image.width(), image.height()));
}

inline void QPainter::drawImage(const QPoint &p, const QImage &image)
{
    drawImage(QRectF(p.x(), p.y(), -1, -1), image, QRectF(0, 0, image.width(), image.height()));
}

inline void QPainter::drawImage(int x, int y, const QImage &image, int sx, int sy, int sw, int sh,
                                Qt::ImageConversionFlags flags)
{
    drawImage(QRectF(x, y, -1, -1), image, QRectF(sx, sy, sw, sh), flags);
}

inline void QPainter::drawTextItem(const QPoint &p, const QTextItem &ti)
{
    drawTextItem(QPointF(p), ti);
}

inline void QPainter::drawText(const QPoint &p, const QString &s)
{
    drawText(QPointF(p), s);
}

inline void QPainter::drawText(int x, int y, int w, int h, int flags, const QString &str, QRect *br)
{
    drawText(QRect(x, y, w, h), flags, str, br);
}

inline void QPainter::drawText(int x, int y, const QString &s)
{
    drawText(QPointF(x, y), s);
}

inline QRect QPainter::boundingRect(int x, int y, int w, int h, int flags, const QString &text)
{
    return boundingRect(QRect(x, y, w, h), flags, text);
}

inline void QPainter::translate(qreal dx, qreal dy)
{
    translate(QPointF(dx, dy));
}

inline void QPainter::translate(const QPoint &offset)
{
    translate(offset.x(), offset.y());
}

inline void QPainter::setViewport(int x, int y, int w, int h)
{
    setViewport(QRect(x, y, w, h));
}

inline void QPainter::setWindow(int x, int y, int w, int h)
{
    setWindow(QRect(x, y, w, h));
}


inline void QPainter::drawPicture(int x, int y, const QPicture &p)
{
    drawPicture(QPoint(x, y), p);
}

inline void QPainter::drawPicture(const QPoint &pt, const QPicture &p)
{
    drawPicture(QPointF(pt), p);
}




#line 2 "../../include/QtGui/qpainter.h"
#line 28 "../../include/QtGui/../../src/gui/painting/qpaintengine.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QFontEngine;
class QLineF;
class QPaintDevice;
class QPaintEnginePrivate;
class QPainterPath;
class QPointF;
class QPolygonF;
class QRectF;
struct QGlyphLayout;
class QTextItemInt;
class QPaintEngineState;

class  QTextItem {
public:
    enum RenderFlag {
        RightToLeft = 0x1,
        Overline = 0x10,
        Underline = 0x20,
        StrikeOut = 0x40,

        Dummy = 0xffffffff
    };
    typedef QFlags<RenderFlag> RenderFlags;
    qreal descent() const;
    qreal ascent() const;
    qreal width() const;

    RenderFlags renderFlags() const;
    QString text() const;
    QFont font() const;
};
template <> class QTypeInfo<QTextItem> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextItem)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextItem"; } };


class  QPaintEngine
{
    inline QPaintEnginePrivate* d_func() { return reinterpret_cast<QPaintEnginePrivate * >(d_ptr); } inline const QPaintEnginePrivate* d_func() const { return reinterpret_cast<const QPaintEnginePrivate * >(d_ptr); } friend class QPaintEnginePrivate;
public:
    enum PaintEngineFeature {
        PrimitiveTransform        = 0x00000001, 
        PatternTransform          = 0x00000002, 
        PixmapTransform           = 0x00000004, 
        PatternBrush              = 0x00000008, 
        LinearGradientFill   	  = 0x00000010, 
        RadialGradientFill        = 0x00000020, 
        ConicalGradientFill       = 0x00000040, 
	AlphaBlend                = 0x00000080, 
	PorterDuff                = 0x00000100, 
        PainterPaths              = 0x00000200, 
        Antialiasing              = 0x00000400, 
        BrushStroke               = 0x00000800, 
        PaintOutsidePaintEvent    = 0x20000000, 
        AllFeatures               = 0xffffffff  
    };
    typedef QFlags<PaintEngineFeature> PaintEngineFeatures;

    enum DirtyFlag {
        DirtyPen                = 0x0001,
        DirtyBrush              = 0x0002,
        DirtyBrushOrigin        = 0x0004,
        DirtyFont               = 0x0008,
        DirtyBackground         = 0x0010,
        DirtyBackgroundMode     = 0x0020,
        DirtyTransform          = 0x0040,
        DirtyClipRegion         = 0x0080,
        DirtyClipPath           = 0x0100,
        DirtyHints              = 0x0200,
        DirtyCompositionMode    = 0x0400,
        DirtyClipEnabled        = 0x0800,

        AllDirty                = 0xffff
    };
    typedef QFlags<DirtyFlag> DirtyFlags;

    enum PolygonDrawMode {
        OddEvenMode,
        WindingMode,
        ConvexMode,
        PolylineMode
    };

    explicit QPaintEngine(PaintEngineFeatures features=0);
    virtual ~QPaintEngine();

    bool isActive() const { return active; }
    void setActive(bool newState) { active = newState; }

    virtual bool begin(QPaintDevice *pdev) = 0;
    virtual bool end() = 0;

    virtual void updateState(const QPaintEngineState &state) = 0;

    virtual void drawRects(const QRect *rects, int rectCount);
    virtual void drawRects(const QRectF *rects, int rectCount);

    virtual void drawLines(const QLine *lines, int lineCount);
    virtual void drawLines(const QLineF *lines, int lineCount);

    virtual void drawEllipse(const QRectF &r);
    virtual void drawEllipse(const QRect &r);

    virtual void drawPath(const QPainterPath &path);

    virtual void drawPoints(const QPointF *points, int pointCount);
    virtual void drawPoints(const QPoint *points, int pointCount);

    virtual void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
    virtual void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode);

    virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) = 0;
    virtual void drawTextItem(const QPointF &p, const QTextItem &textItem);
    virtual void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
    virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
                           Qt::ImageConversionFlags flags = Qt::AutoColor);

    void setPaintDevice(QPaintDevice *device);
    QPaintDevice *paintDevice() const;

    void setSystemClip(const QRegion &baseClip);
    QRegion systemClip() const;

    void setSystemRect(const QRect &rect);
    QRect systemRect() const;






    virtual QPoint coordinateOffset() const;

    enum Type {
        X11,
        Windows,
        QuickDraw, CoreGraphics, MacPrinter,
        QWindowSystem,
        PostScript,
        OpenGL,
        Picture,
        SVG,
        Raster,

        User = 50,    
        MaxUser = 100 
    };
    virtual Type type() const = 0;

    inline void fix_neg_rect(int *x, int *y, int *w, int *h);

    inline bool testDirty(DirtyFlags df);
    inline void setDirty(DirtyFlags df);
    inline void clearDirty(DirtyFlags df);

    bool hasFeature(PaintEngineFeatures feature) const { return (gccaps & feature) != 0; }

    QPainter *painter() const;

    inline void syncState() { do {if(!(state))qt_assert("state","../../include/QtGui/../../src/gui/painting/qpaintengine.h",190);} while (0); updateState(*state); }

protected:
    QPaintEngine(QPaintEnginePrivate &data, PaintEngineFeatures devcaps=0);

    QPaintEngineState *state;
    PaintEngineFeatures gccaps;

    uint active : 1;
    uint selfDestruct : 1;

    QPaintEnginePrivate *d_ptr;

private:
    void setAutoDestruct(bool autoDestr) { selfDestruct = autoDestr; }
    bool autoDestruct() const { return selfDestruct; }

    friend class QFontEngineBox;
    friend class QFontEngineMac;
    friend class QFontEngineWin;

    friend class QFontEngineFT;


    friend class QFontEngineQPF;

    friend class QPSPrintEngine;
    friend class QMacPrintEngine;
    friend class QMacPrintEnginePrivate;
    friend class QPainter;
    friend class QPainterPrivate;
    friend class QWidget;
    friend class QWin32PaintEngine;
    friend class QWin32PaintEnginePrivate;
    friend class QMacCGContext;
};


class  QPaintEngineState
{
public:
    QPaintEngine::DirtyFlags state() const { return dirtyFlags; }

    QPen pen() const;

    QBrush brush() const;
    QPointF brushOrigin() const;

    QBrush backgroundBrush() const;
    Qt::BGMode backgroundMode() const;

    QFont font() const;

    QMatrix matrix() const;

    Qt::ClipOperation clipOperation() const;
    QRegion clipRegion() const;
    QPainterPath clipPath() const;
    bool isClipEnabled() const;

    QPainter::RenderHints renderHints() const;

    QPainter::CompositionMode compositionMode() const;



    QPainter *painter() const;

protected:
    friend class QPaintEngine;
    friend class QPainter;
    friend class QPainterPrivate;

    QPaintEngine::DirtyFlags dirtyFlags;
};





inline void QPaintEngine::fix_neg_rect(int *x, int *y, int *w, int *h)
{
    if (*w < 0) {
        *w = -*w;
        *x -= *w - 1;
    }
    if (*h < 0) {
        *h = -*h;
        *y -= *h - 1;
    }
}

inline bool QPaintEngine::testDirty(DirtyFlags df) {
    do {if(!(state))qt_assert("state","../../include/QtGui/../../src/gui/painting/qpaintengine.h",283);} while (0);
    return ((state->dirtyFlags & df) != 0);
}

inline void QPaintEngine::setDirty(DirtyFlags df) {
    do {if(!(state))qt_assert("state","../../include/QtGui/../../src/gui/painting/qpaintengine.h",288);} while (0);
    state->dirtyFlags |= df;
}

inline void QPaintEngine::clearDirty(DirtyFlags df)
{
    do {if(!(state))qt_assert("state","../../include/QtGui/../../src/gui/painting/qpaintengine.h",294);} while (0);
    state->dirtyFlags &= ~static_cast<uint>(df);
}

inline QFlags<QTextItem::RenderFlags::enum_type> operator|(QTextItem::RenderFlags::enum_type f1, QTextItem::RenderFlags::enum_type f2) { return QFlags<QTextItem::RenderFlags::enum_type>(f1) | f2; } inline QFlags<QTextItem::RenderFlags::enum_type> operator|(QTextItem::RenderFlags::enum_type f1, QFlags<QTextItem::RenderFlags::enum_type> f2) { return f2 | f1; }
inline QFlags<QPaintEngine::PaintEngineFeatures::enum_type> operator|(QPaintEngine::PaintEngineFeatures::enum_type f1, QPaintEngine::PaintEngineFeatures::enum_type f2) { return QFlags<QPaintEngine::PaintEngineFeatures::enum_type>(f1) | f2; } inline QFlags<QPaintEngine::PaintEngineFeatures::enum_type> operator|(QPaintEngine::PaintEngineFeatures::enum_type f1, QFlags<QPaintEngine::PaintEngineFeatures::enum_type> f2) { return f2 | f1; }
inline QFlags<QPaintEngine::DirtyFlags::enum_type> operator|(QPaintEngine::DirtyFlags::enum_type f1, QPaintEngine::DirtyFlags::enum_type f2) { return QFlags<QPaintEngine::DirtyFlags::enum_type>(f1) | f2; } inline QFlags<QPaintEngine::DirtyFlags::enum_type> operator|(QPaintEngine::DirtyFlags::enum_type f1, QFlags<QPaintEngine::DirtyFlags::enum_type> f2) { return f2 | f1; }



#line 2 "../../include/QtGui/qpaintengine.h"
#line 44 "text/qtextengine_p.h"
#line 1 "../../include/QtGui/qtextobject.h"
#line 1 "../../include/QtGui/../../src/gui/text/qtextobject.h"



















 




#line 1 "../../include/QtCore/qobject.h"
#line 26 "../../include/QtGui/../../src/gui/text/qtextobject.h"
#line 1 "../../include/QtGui/qtextformat.h"
#line 27 "../../include/QtGui/../../src/gui/text/qtextobject.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QTextObjectPrivate;
class QTextDocument;
class QTextDocumentPrivate;
class QTextCursor;
class QTextBlock;
class QTextFragment;
class QTextLayout;
class QTextList;

class  QTextObject : public QObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:

protected:
    explicit QTextObject(QTextDocument *doc);
    ~QTextObject();

    void setFormat(const QTextFormat &format);

public:
    QTextFormat format() const;
    int formatIndex() const;

    QTextDocument *document() const;

    int objectIndex() const;

    QTextDocumentPrivate *docHandle() const;

protected:
    QTextObject(QTextObjectPrivate &p, QTextDocument *doc);

private:
    inline QTextObjectPrivate* d_func() { return reinterpret_cast<QTextObjectPrivate * >(d_ptr); } inline const QTextObjectPrivate* d_func() const { return reinterpret_cast<const QTextObjectPrivate * >(d_ptr); } friend class QTextObjectPrivate;
    QTextObject(const QTextObject &); QTextObject &operator=(const QTextObject &);
    friend class QTextDocumentPrivate;
};

class QTextBlockGroupPrivate;
class  QTextBlockGroup : public QTextObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:

protected:
    explicit QTextBlockGroup(QTextDocument *doc);
    ~QTextBlockGroup();

    virtual void blockInserted(const QTextBlock &block);
    virtual void blockRemoved(const QTextBlock &block);
    virtual void blockFormatChanged(const QTextBlock &block);

    QList<QTextBlock> blockList() const;

protected:
    QTextBlockGroup(QTextBlockGroupPrivate &p, QTextDocument *doc);
private:
    inline QTextBlockGroupPrivate* d_func() { return reinterpret_cast<QTextBlockGroupPrivate * >(d_ptr); } inline const QTextBlockGroupPrivate* d_func() const { return reinterpret_cast<const QTextBlockGroupPrivate * >(d_ptr); } friend class QTextBlockGroupPrivate;
    QTextBlockGroup(const QTextBlockGroup &); QTextBlockGroup &operator=(const QTextBlockGroup &);
    friend class QTextDocumentPrivate;
};

class  QTextFrameLayoutData {
public:
    virtual ~QTextFrameLayoutData();
};

class QTextFramePrivate;
class  QTextFrame : public QTextObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:

public:
    explicit QTextFrame(QTextDocument *doc);
    ~QTextFrame();

    inline void setFrameFormat(const QTextFrameFormat &format);
    QTextFrameFormat frameFormat() const { return QTextObject::format().toFrameFormat(); }

    QTextCursor firstCursorPosition() const;
    QTextCursor lastCursorPosition() const;
    int firstPosition() const;
    int lastPosition() const;

    QTextFrameLayoutData *layoutData() const;
    void setLayoutData(QTextFrameLayoutData *data);

    QList<QTextFrame *> childFrames() const;
    QTextFrame *parentFrame() const;

    class  iterator {
        QTextFrame *f;
        int b;
        int e;
        QTextFrame *cf;
        int cb;

        friend class QTextFrame;
        friend class QTextTableCell;
        friend class QTextDocumentLayoutPrivate;
        iterator(QTextFrame *frame, int block, int begin, int end);
    public:
        iterator();
        iterator(const iterator &o);
        iterator &operator=(const iterator &o);

        QTextFrame *parentFrame() const { return f; }

        QTextFrame *currentFrame() const;
        QTextBlock currentBlock() const;

        bool atEnd() const { return !cf && cb == e; }

        inline bool operator==(const iterator &o) const { return f == o.f && cf == o.cf && cb == o.cb; }
        inline bool operator!=(const iterator &o) const { return f != o.f || cf != o.cf || cb != o.cb; }
        iterator &operator++();
        inline iterator operator++(int) { iterator tmp = *this; operator++(); return tmp; }
        iterator &operator--();
        inline iterator operator--(int) { iterator tmp = *this; operator--(); return tmp; }
    };

    
    typedef iterator Iterator;

    iterator begin() const;
    iterator end() const;

protected:
    QTextFrame(QTextFramePrivate &p, QTextDocument *doc);
private:
    friend class QTextDocumentPrivate;
    inline QTextFramePrivate* d_func() { return reinterpret_cast<QTextFramePrivate * >(d_ptr); } inline const QTextFramePrivate* d_func() const { return reinterpret_cast<const QTextFramePrivate * >(d_ptr); } friend class QTextFramePrivate;
    QTextFrame(const QTextFrame &); QTextFrame &operator=(const QTextFrame &);
};
template <> class QTypeInfo<QTextFrame::iterator> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextFrame::iterator)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextFrame::iterator"; } };

inline void QTextFrame::setFrameFormat(const QTextFrameFormat &aformat)
{ QTextObject::setFormat(aformat); }

class  QTextBlockUserData {
public:
    virtual ~QTextBlockUserData();
};

class  QTextBlock
{
    friend class QSyntaxHighlighter;
public:
    inline QTextBlock(QTextDocumentPrivate *priv, int b) : p(priv), n(b) {}
    inline QTextBlock() : p(0), n(0) {}
    inline QTextBlock(const QTextBlock &o) : p(o.p), n(o.n) {}
    inline QTextBlock &operator=(const QTextBlock &o) { p = o.p; n = o.n; return *this; }

    inline bool isValid() const { return p != 0 && n != 0; }

    inline bool operator==(const QTextBlock &o) const { return p == o.p && n == o.n; }
    inline bool operator!=(const QTextBlock &o) const { return p != o.p || n != o.n; }
    inline bool operator<(const QTextBlock &o) const { return position() < o.position(); }

    int position() const;
    int length() const;
    bool contains(int position) const;

    QTextLayout *layout() const;
    QTextBlockFormat blockFormat() const;
    int blockFormatIndex() const;
    QTextCharFormat charFormat() const;
    int charFormatIndex() const;

    QString text() const;

    const QTextDocument *document() const;

    QTextList *textList() const;

    QTextBlockUserData *userData() const;
    void setUserData(QTextBlockUserData *data);

    int userState() const;
    void setUserState(int state);

    class  iterator {
        const QTextDocumentPrivate *p;
        int b;
        int e;
        int n;
        friend class QTextBlock;
        iterator(const QTextDocumentPrivate *priv, int begin, int end, int f) : p(priv), b(begin), e(end), n(f) {}
    public:
        iterator() : p(0), b(0), e(0), n(0) {}
        iterator(const iterator &o) : p(o.p), b(o.b), e(o.e), n(o.n) {}

        QTextFragment fragment() const;

        bool atEnd() const { return n == e; }

        inline bool operator==(const iterator &o) const { return p == o.p && n == o.n; }
        inline bool operator!=(const iterator &o) const { return p != o.p || n != o.n; }
        iterator &operator++();
        inline iterator operator++(int) { iterator tmp = *this; operator++(); return tmp; }
        iterator &operator--();
        inline iterator operator--(int) { iterator tmp = *this; operator--(); return tmp; }
    };

    
    typedef iterator Iterator;

    iterator begin() const;
    iterator end() const;

    QTextBlock next() const;
    QTextBlock previous() const;

    inline QTextDocumentPrivate *docHandle() const { return p; }

private:
    QTextDocumentPrivate *p;
    int n;
    friend class QTextDocumentPrivate;
    friend class QTextLayout;
};

template <> class QTypeInfo<QTextBlock> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextBlock)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextBlock"; } };
template <> class QTypeInfo<QTextBlock::iterator> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextBlock::iterator)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextBlock::iterator"; } };


class  QTextFragment
{
public:
    inline QTextFragment(const QTextDocumentPrivate *priv, int f, int fe) : p(priv), n(f), ne(fe) {}
    inline QTextFragment() : p(0), n(0), ne(0) {}
    inline QTextFragment(const QTextFragment &o) : p(o.p), n(o.n), ne(o.ne) {}
    inline QTextFragment &operator=(const QTextFragment &o) { p = o.p; n = o.n; ne = o.ne; return *this; }

    inline bool isValid() const { return p && n; }

    inline bool operator==(const QTextFragment &o) const { return p == o.p && n == o.n; }
    inline bool operator!=(const QTextFragment &o) const { return p != o.p || n != o.n; }
    inline bool operator<(const QTextFragment &o) const { return position() < o.position(); }

    int position() const;
    int length() const;
    bool contains(int position) const;

    QTextCharFormat charFormat() const;
    int charFormatIndex() const;
    QString text() const;

private:
    const QTextDocumentPrivate *p;
    int n;
    int ne;
};

template <> class QTypeInfo<QTextFragment> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextFragment)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextFragment"; } };



#line 2 "../../include/QtGui/qtextobject.h"
#line 45 "text/qtextengine_p.h"
#line 1 "../../include/QtGui/qtextoption.h"
#line 46 "text/qtextengine_p.h"
#line 1 "../../include/QtGui/private/qtextdocument_p.h"
#line 1 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"



















 















#line 1 "../../include/QtCore/qglobal.h"
#line 37 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtCore/qstring.h"
#line 38 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtCore/qvector.h"
#line 39 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtCore/qlist.h"
#line 40 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtCore/private/qobject_p.h"
#line 1 "../../include/QtCore/private/../../../src/corelib/kernel/qobject_p.h"



















 















#line 1 "../../include/QtCore/qobject.h"
#line 37 "../../include/QtCore/private/../../../src/corelib/kernel/qobject_p.h"
#line 1 "../../include/QtCore/qpointer.h"
#line 1 "../../include/QtCore/../../src/corelib/kernel/qpointer.h"



















 




#line 1 "../../include/QtCore/qobject.h"
#line 26 "../../include/QtCore/../../src/corelib/kernel/qpointer.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

template <class T>
class QPointer
{
    QObject *o;
public:
    inline QPointer() : o(0) {}
    inline QPointer(T *p) : o(p)
        { QMetaObject::addGuard(&o); }
    inline QPointer(const QPointer<T> &p) : o(p.o)
        { QMetaObject::addGuard(&o); }
    inline ~QPointer()
        { QMetaObject::removeGuard(&o); }
    inline QPointer<T> &operator=(const QPointer<T> &p)
        { if (this != &p) QMetaObject::changeGuard(&o, p.o); return *this; }
    inline QPointer<T> &operator=(T* p)
        { if (o != p) QMetaObject::changeGuard(&o, p); return *this; }

    inline bool isNull() const
        { return !o; }

    inline T* operator->() const
        { return static_cast<T*>(const_cast<QObject*>(o)); }
    inline T& operator*() const
        { return *static_cast<T*>(const_cast<QObject*>(o)); }
    inline operator T*() const
        { return static_cast<T*>(const_cast<QObject*>(o)); }
};


template <class T>
inline bool operator==(const T *o, const QPointer<T> &p)
{ return o == p.operator->(); }


template<class T>
inline bool operator==(const QPointer<T> &p, const T *o)
{ return p.operator->() == o; }


template <class T>
inline bool operator==(T *o, const QPointer<T> &p)
{ return o == p.operator->(); }

template<class T>
inline bool operator==(const QPointer<T> &p, T *o)
{ return p.operator->() == o; }

template<class T>
inline bool operator==(const QPointer<T> &p1, const QPointer<T> &p2)
{ return p1.operator->() == p2.operator->(); }


template <class T>
inline bool operator!=(const T *o, const QPointer<T> &p)
{ return o != p.operator->(); }


template<class T>
inline bool operator!= (const QPointer<T> &p, const T *o)
{ return p.operator->() != o; }


template <class T>
inline bool operator!=(T *o, const QPointer<T> &p)
{ return o != p.operator->(); }

template<class T>
inline bool operator!= (const QPointer<T> &p, T *o)
{ return p.operator->() != o; }

template<class T>
inline bool operator!= (const QPointer<T> &p1, const QPointer<T> &p2)
{ return p1.operator->() != p2.operator->() ; }



#line 2 "../../include/QtCore/qpointer.h"
#line 38 "../../include/QtCore/private/../../../src/corelib/kernel/qobject_p.h"
#line 1 "../../include/QtCore/qcoreevent.h"
#line 39 "../../include/QtCore/private/../../../src/corelib/kernel/qobject_p.h"
#line 1 "../../include/QtCore/qlist.h"
#line 40 "../../include/QtCore/private/../../../src/corelib/kernel/qobject_p.h"
#line 1 "../../include/QtCore/qvector.h"
#line 41 "../../include/QtCore/private/../../../src/corelib/kernel/qobject_p.h"
#line 1 "../../include/QtCore/qreadwritelock.h"
#line 1 "../../include/QtCore/../../src/corelib/thread/qreadwritelock.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtCore/../../src/corelib/thread/qreadwritelock.h"




typedef QtValidLicenseForCoreModule QtCoreModule;



struct QReadWriteLockPrivate;

class  QReadWriteLock
{
public:
    QReadWriteLock();
    ~QReadWriteLock();

    void lockForRead();
    bool tryLockForRead();

    void lockForWrite();
    bool tryLockForWrite();

    void unlock();

private:
    QReadWriteLock(const QReadWriteLock &); QReadWriteLock &operator=(const QReadWriteLock &);
    QReadWriteLockPrivate *d;
};

class  QReadLocker
{
public:
    inline QReadLocker(QReadWriteLock *readWriteLock);

    inline ~QReadLocker()
    { unlock(); }

    inline void unlock()
    { if (q_lock) q_lock->unlock(); }

    inline void relock()
    { if (q_lock) q_lock->lockForRead(); }

    inline QReadWriteLock *readWriteLock() const
    { return q_lock; }

private:
    QReadLocker(const QReadLocker &); QReadLocker &operator=(const QReadLocker &);
    QReadWriteLock *q_lock;
};

inline QReadLocker::QReadLocker(QReadWriteLock *areadWriteLock)
    : q_lock(areadWriteLock)
{ relock(); }

class  QWriteLocker
{
public:
    inline QWriteLocker(QReadWriteLock *readWriteLock);

    inline ~QWriteLocker()
    { unlock(); }

    inline void unlock()
    { if (q_lock) q_lock->unlock(); }

    inline void relock()
    { if (q_lock) q_lock->lockForWrite(); }

    inline QReadWriteLock *readWriteLock() const
    { return q_lock; }

private:
    QWriteLocker(const QWriteLocker &); QWriteLocker &operator=(const QWriteLocker &);
    QReadWriteLock *q_lock;
};

inline QWriteLocker::QWriteLocker(QReadWriteLock *areadWriteLock)
    : q_lock(areadWriteLock)
{ relock(); }

#line 156 "../../include/QtCore/../../src/corelib/thread/qreadwritelock.h"



#line 2 "../../include/QtCore/qreadwritelock.h"
#line 42 "../../include/QtCore/private/../../../src/corelib/kernel/qobject_p.h"

class QThreadData;

 
struct QSignalSpyCallbackSet
{
    typedef void (*BeginCallback)(QObject *caller, int method_index, void **argv);
    typedef void (*EndCallback)(QObject *caller, int method_index);
    BeginCallback signal_begin_callback,
                    slot_begin_callback;
    EndCallback signal_end_callback,
                slot_end_callback;
};
void  qt_register_signal_spy_callbacks(const QSignalSpyCallbackSet &callback_set);

extern QSignalSpyCallbackSet  qt_signal_spy_callback_set;

inline QObjectData::~QObjectData() {}

enum { QObjectPrivateVersion = 0x040104 };

class  QObjectPrivate : public QObjectData
{
    inline QObject* q_func() { return static_cast<QObject * >(q_ptr); } inline const QObject* q_func() const { return static_cast<const QObject * >(q_ptr); } friend class QObject;

public:
    
    static QReadWriteLock *readWriteLock();
    
    static bool isValidObject(QObject *object);

    QObjectPrivate(int version = QObjectPrivateVersion);
    virtual ~QObjectPrivate();

    
    int thread;
    void moveToThread_helper(QThread *targetThread);
    void setThreadId_helper(QThreadData *currentData, QThreadData *targetData, int id);
    void _q_reregisterTimers(void *pointer);

    
    QObject *currentSender;

    bool isSender(const QObject *receiver, const char *signal) const;
    QObjectList receiverList(const char *signal) const;
    QObjectList senderList() const;

    QList<QPointer<QObject> > eventFilters;

    void setParent_helper(QObject *);


    QVector<QObjectUserData *> userData;


    QString objectName;
};

class  QMetaCallEvent : public QEvent
{
public:
    QMetaCallEvent(int id, const QObject *sender = 0,
                   int nargs = 0, int *types = 0, void **args = 0);
    ~QMetaCallEvent();

    inline int id() const { return id_; }
    inline const QObject *sender() const { return sender_; }
    inline void **args() const { return args_; }

private:
    int id_;
    const QObject *sender_;
    int nargs_;
    int *types_;
    void **args_;
};

class  QBoolBlocker
{
public:
    inline QBoolBlocker(bool &b):block(b), reset(b){block = true;}
    inline ~QBoolBlocker(){block = reset; }
private:
    bool &block;
    bool reset;
};

#line 2 "../../include/QtCore/private/qobject_p.h"
#line 41 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtGui/private/qfragmentmap_p.h"
#line 1 "../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h"



















 















#line 1 "../../include/QtCore/qglobal.h"
#line 37 "../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h"


template <class T> class QFragmentMap;

class QFragment
{
public:
    quint32 size_left;
    quint32 parent;
    quint32 left;
    quint32 right;
    quint32 color : 1;
    quint32 size : 31;
};

class QFragmentMapData
{
    enum Color { Red, Black };
public:
    QFragmentMapData(uint fs);
    ~QFragmentMapData();

    void init();

    class Header
    {
    public:
        quint32 tag;
        quint32 root; 
        quint32 unused1;
        quint32 unused2;
        quint32 size; 
        quint32 freelist;
        quint32 node_count;
        quint32 allocated;
    };


    int length() const;


    inline QFragment *fragment(uint index) {
        return (QFragment *)(fragments + index*fragmentSize);
    }
    inline const QFragment *fragment(uint index) const {
        return (QFragment *)(fragments + index*fragmentSize);
    }

    inline bool isRoot(uint index) const {
        return !fragment(index)->parent;
    }

    inline uint position(uint node) const {
        const QFragment *f = fragment(node);
        uint offset = f->size_left;
        while (f->parent) {
            uint p = f->parent;
            f = fragment(p);
            if (f->right == node)
                offset += f->size_left + f->size;
            node = p;
        }
        return offset;
    }
    inline uint sizeRight(uint node) const {
        uint sr = 0;
        const QFragment *f = fragment(node);
        node = f->right;
        while (node) {
            f = fragment(node);
            sr += f->size_left + f->size;
            node = f->right;
        }
        return sr;
    }
    inline uint sizeLeft(uint node) const {
        return fragment(node)->size_left;
    }

    inline uint size(uint node) const { return fragment(node)->size; }
    inline void setSize(uint node, int new_size) {
        QFragment *f = fragment(node);
        int diff = new_size - f->size;
        f->size = new_size;
        while (f->parent) {
            uint p = f->parent;
            f = fragment(p);
            if (f->left == node)
                f->size_left += diff;
            node = p;
        }
    }


    uint findNode(int k) const;

    uint insert_single(int key, uint length);
    uint erase_single(uint f);

#line 150 "../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h"
    uint minimum(uint n) const {
        while (n && fragment(n)->left)
            n = fragment(n)->left;
        return n;
    }

    uint maximum(uint n) const {
        while (n && fragment(n)->right)
            n = fragment(n)->right;
        return n;
    }

    uint next(uint n) const;
    uint previous(uint n) const;

    inline uint root() const {
        do {if(!(!head->root || !fragment(head->root)->parent))qt_assert("!head->root || !fragment(head->root)->parent","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",166);} while (0);
        return head->root;
    }
    inline void setRoot(uint new_root) {
        do {if(!(!head->root || !fragment(new_root)->parent))qt_assert("!head->root || !fragment(new_root)->parent","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",170);} while (0);
        head->root = new_root;
    }

    void rotateLeft(uint x);
    void rotateRight(uint x);
    void rebalance(uint x);
    void removeAndRebalance(uint z);

    uint createFragment();
    void freeFragment(uint f);

    union {
        Header *head;
        char *fragments;
    };
    const int fragmentSize;
};

template <class T>
class QFragmentMap
{
public:
    class Iterator
    {
    public:
        QFragmentMap *pt;
        quint32 n;

        Iterator() : pt(0), n(0) {}
        Iterator(QFragmentMap *p, int node) : pt(p), n(node) {}
        Iterator(const Iterator& it) : pt(it.pt), n(it.n) {}

        inline bool atEnd() const { return !n; }

        bool operator==(const Iterator& it) const { return pt == it.pt && n == it.n; }
        bool operator!=(const Iterator& it) const { return pt != it.pt || n != it.n; }
        bool operator<(const Iterator &it) const { return position() < it.position(); }

        T *operator*() { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",209);} while (0); return pt->fragment(n); }
        const T *operator*() const { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",210);} while (0); return pt->fragment(n); }
        T *operator->() { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",211);} while (0); return pt->fragment(n); }
        const T *operator->() const { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",212);} while (0); return pt->fragment(n); }

        int position() const { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",214);} while (0); return pt->data.position(n); }
        const T *value() const { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",215);} while (0); return pt->fragment(n); }
        T *value() { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",216);} while (0); return pt->fragment(n); }

        Iterator& operator++() {
            n = pt->data.next(n);
            return *this;
        }
        Iterator& operator--() {
            n = pt->data.previous(n);
            return *this;
        }

    };


    class ConstIterator
    {
    public:
        const QFragmentMap *pt;
        quint32 n;

        

 
        ConstIterator() : pt(0), n(0) {}
        ConstIterator(const QFragmentMap *p, int node) : pt(p), n(node) {}
        ConstIterator(const ConstIterator& it) : pt(it.pt), n(it.n) {}
        ConstIterator(const Iterator& it) : pt(it.pt), n(it.n) {}

        inline bool atEnd() const { return !n; }

        bool operator==(const ConstIterator& it) const { return pt == it.pt && n == it.n; }
        bool operator!=(const ConstIterator& it) const { return pt != it.pt || n != it.n; }
        bool operator<(const ConstIterator &it) const { return position() < it.position(); }

        const T *operator*()  const { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",250);} while (0); return pt->fragment(n); }
        const T *operator->()  const { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",251);} while (0); return pt->fragment(n); }

        int position() const { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",253);} while (0); return pt->data.position(n); }
        int size() const { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",254);} while (0); return pt->data.size(n); }
        const T *value() const { do {if(!(!atEnd()))qt_assert("!atEnd()","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",255);} while (0); return pt->fragment(n); }

        ConstIterator& operator++() {
            n = pt->data.next(n);
            return *this;
        }
        ConstIterator& operator--() {
            n = pt->data.previous(n);
            return *this;
        }
    };


    QFragmentMap() : data(sizeof(T)) {}
    ~QFragmentMap()
    {
        for (Iterator it = begin(); !it.atEnd(); ++it)
            it.value()->free();
    }

    inline void clear() {
        for (Iterator it = begin(); !it.atEnd(); ++it)
            it.value()->free();
        ::free(data.head);
        data.init();
    }

    inline Iterator begin() { return Iterator(this, data.minimum(data.root())); }
    inline Iterator end() { return Iterator(this, 0); }
    inline ConstIterator begin() const { return ConstIterator(this, data.minimum(data.root())); }
    inline ConstIterator end() const { return ConstIterator(this, 0); }

    inline bool isEmpty() const { return data.head->node_count == 0; }
    inline int numNodes() const { return data.head->node_count; }
    int length() const { return data.length(); }

    Iterator find(int k) { return Iterator(this, data.findNode(k)); }
    ConstIterator find(int k) const { return ConstIterator(this, data.findNode(k)); }

    uint findNode(int k) const { return data.findNode(k); }

    uint insert_single(int key, uint length)
    {
        uint f = data.insert_single(key, length);
        if (f != 0) {
            T *frag = fragment(f);
            do {if(!(frag))qt_assert("frag","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",301);} while (0);
            frag->initialize();
        }
        return f;
    }
    uint erase_single(uint f)
    {
      if (f != 0) {
          T *frag = fragment(f);
          do {if(!(frag))qt_assert("frag","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",310);} while (0);
          frag->free();
      }
      return data.erase_single(f);
    }

    inline T *fragment(uint index) {
        do {if(!(index != 0))qt_assert("index != 0","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",317);} while (0);
        return static_cast<T *>(data.fragment(index));
    }
    inline const T *fragment(uint index) const {
        do {if(!(index != 0))qt_assert("index != 0","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",321);} while (0);
        return static_cast<const T *>(data.fragment(index));
    }
    inline uint position(uint node) const { return data.position(node); }
    inline uint next(uint n) const { return data.next(n); }
    inline uint previous(uint n) const { return data.previous(n); }
    inline uint size(uint node) const { return data.size(node); }
    inline void setSize(uint node, int new_size)
    { data.setSize(node, new_size);
      if (node != 0) {
          T *frag = fragment(node);
          do {if(!(frag))qt_assert("frag","../../include/QtGui/private/../../../src/gui/text/qfragmentmap_p.h",332);} while (0);
          frag->invalidate();
      }
    }

    inline int firstNode() const { return data.minimum(data.root()); }

private:
    friend class Iterator;
    friend class ConstIterator;

    QFragmentMapData data;

    QFragmentMap(const QFragmentMap& m);
    QFragmentMap& operator= (const QFragmentMap& m);
};

#line 2 "../../include/QtGui/private/qfragmentmap_p.h"
#line 42 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtGui/qtextlayout.h"
#line 43 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtGui/private/qtextformat_p.h"
#line 44 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtGui/qtextdocument.h"
#line 1 "../../include/QtGui/../../src/gui/text/qtextdocument.h"



















 




#line 1 "../../include/QtCore/qobject.h"
#line 26 "../../include/QtGui/../../src/gui/text/qtextdocument.h"
#line 1 "../../include/QtCore/qsize.h"
#line 27 "../../include/QtGui/../../src/gui/text/qtextdocument.h"
#line 1 "../../include/QtGui/qfont.h"
#line 28 "../../include/QtGui/../../src/gui/text/qtextdocument.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QTextFormatCollection;
class QTextListFormat;
class QRect;
class QPainter;
class QPrinter;
class QAbstractTextDocumentLayout;
class QPoint;
class QTextCursor;
class QTextObject;
class QTextFormat;
class QTextFrame;
class QTextBlock;
class QTextCodec;
class QUrl;
class QVariant;
class QRectF;

template<typename T> class QVector;

namespace Qt
{
    enum HitTestAccuracy { ExactHit, FuzzyHit };
    enum WhiteSpaceMode {
        WhiteSpaceNormal,
        WhiteSpacePre,
        WhiteSpaceNoWrap,
        WhiteSpaceModeUndefined = -1
    };

     bool mightBeRichText(const QString&);
     QString escape(const QString& plain);
     QString convertFromPlainText(const QString &plain, WhiteSpaceMode mode = WhiteSpacePre);


     QTextCodec *codecForHtml(const QByteArray &ba);

}

class  QAbstractUndoItem
{
public:
    virtual ~QAbstractUndoItem() = 0;
    virtual void undo() = 0;
    virtual void redo() = 0;
};

inline QAbstractUndoItem::~QAbstractUndoItem()
{
}

class QTextDocumentPrivate;

class  QTextDocument : public QObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:

    
    
    
    
    

public:
    explicit QTextDocument(QObject *parent = 0);
    explicit QTextDocument(const QString &text, QObject *parent = 0);
    ~QTextDocument();

    QTextDocument *clone(QObject *parent = 0) const;

    bool isEmpty() const;
    virtual void clear();

    void setUndoRedoEnabled(bool enable);
    bool isUndoRedoEnabled() const;

    bool isUndoAvailable() const;
    bool isRedoAvailable() const;

    void setDocumentLayout(QAbstractTextDocumentLayout *layout);
    QAbstractTextDocumentLayout *documentLayout() const;

    enum MetaInformation {
        DocumentTitle
    };
    void setMetaInformation(MetaInformation info, const QString &);
    QString metaInformation(MetaInformation info) const;

    QString toHtml(const QByteArray &encoding = QByteArray()) const;
    void setHtml(const QString &html);

    QString toPlainText() const;
    void setPlainText(const QString &text);

    enum FindFlag
    {
        FindBackward        = 0x00001,
        FindCaseSensitively = 0x00002,
        FindWholeWords      = 0x00004
    };
    typedef QFlags<FindFlag> FindFlags;

    QTextCursor find(const QString &expr, int from = 0, FindFlags options = 0) const;
    QTextCursor find(const QString &expr, const QTextCursor &from, FindFlags options = 0) const;

    QTextFrame *frameAt(int pos) const;
    QTextFrame *rootFrame() const;

    QTextObject *object(int objectIndex) const;
    QTextObject *objectForFormat(const QTextFormat &) const;

    QTextBlock findBlock(int pos) const;
    QTextBlock begin() const;
    QTextBlock end() const;

    void setPageSize(const QSizeF &size);
    QSizeF pageSize() const;

    void setDefaultFont(const QFont &font);
    QFont defaultFont() const;

    int pageCount() const;

    bool isModified() const;


    void print(QPrinter *printer) const;

    
    enum ResourceType {
        HtmlResource  = 1,
        ImageResource = 2,

        UserResource  = 100
    };

    QVariant resource(int type, const QUrl &name) const;
    void addResource(int type, const QUrl &name, const QVariant &resource);

    QVector<QTextFormat> allFormats() const;

    void markContentsDirty(int from, int length);

    void setUseDesignMetrics(bool b);
    bool useDesignMetrics() const;

protected:
    void contentsChange(int from, int charsRemoves, int charsAdded);
    void contentsChanged();
    void undoAvailable(bool);
    void redoAvailable(bool);
    void modificationChanged(bool m);
    void cursorPositionChanged(const QTextCursor &cursor);

public :
    void undo();
    void redo();
    void appendUndoItem(QAbstractUndoItem *);
    void setModified(bool m = true);

protected:
    virtual QTextObject *createObject(const QTextFormat &f);
    virtual QVariant loadResource(int type, const QUrl &name);

public:
    QTextDocumentPrivate *docHandle() const;
private:
    QTextDocument(const QTextDocument &); QTextDocument &operator=(const QTextDocument &);
    inline QTextDocumentPrivate* d_func() { return reinterpret_cast<QTextDocumentPrivate * >(d_ptr); } inline const QTextDocumentPrivate* d_func() const { return reinterpret_cast<const QTextDocumentPrivate * >(d_ptr); } friend class QTextDocumentPrivate;
};

inline QFlags<QTextDocument::FindFlags::enum_type> operator|(QTextDocument::FindFlags::enum_type f1, QTextDocument::FindFlags::enum_type f2) { return QFlags<QTextDocument::FindFlags::enum_type>(f1) | f2; } inline QFlags<QTextDocument::FindFlags::enum_type> operator|(QTextDocument::FindFlags::enum_type f1, QFlags<QTextDocument::FindFlags::enum_type> f2) { return f2 | f1; }



#line 2 "../../include/QtGui/qtextdocument.h"
#line 45 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtGui/qtextobject.h"
#line 46 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtCore/qmap.h"
#line 47 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtCore/qvariant.h"
#line 48 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"
#line 1 "../../include/QtCore/qurl.h"
#line 1 "../../include/QtCore/../../src/corelib/io/qurl.h"



















 




#line 1 "../../include/QtCore/qobjectdefs.h"
#line 26 "../../include/QtCore/../../src/corelib/io/qurl.h"
#line 1 "../../include/QtCore/qpair.h"
#line 27 "../../include/QtCore/../../src/corelib/io/qurl.h"
#line 1 "../../include/QtCore/qstring.h"
#line 28 "../../include/QtCore/../../src/corelib/io/qurl.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class QByteArray;
class QUrlPrivate;
class QDataStream;

class  QUrl
{
public:
    enum ParsingMode {
        TolerantMode,
        StrictMode
    };

    
    enum FormattingOption {
        None = 0x0,
        RemoveScheme = 0x1,
        RemovePassword = 0x2,
        RemoveUserInfo = RemovePassword | 0x4,
        RemovePort = 0x8,
        RemoveAuthority = RemoveUserInfo | RemovePort | 0x10,
        RemovePath = 0x20,
        RemoveQuery = 0x40,
        RemoveFragment = 0x80,

        StripTrailingSlash = 0x10000
    };
    typedef QFlags<FormattingOption> FormattingOptions;

    QUrl();
    QUrl(const QString &url);
    QUrl(const QString &url, ParsingMode mode);
    
    QUrl(const QUrl &copy);
    QUrl &operator =(const QUrl &copy);
    QUrl &operator =(const QString &url);
    ~QUrl();

    void setUrl(const QString &url);
    void setUrl(const QString &url, ParsingMode mode);
    
    void setEncodedUrl(const QByteArray &url);
    void setEncodedUrl(const QByteArray &url, ParsingMode mode);
    

    bool isValid() const;

    bool isEmpty() const;

    void clear();

    void setScheme(const QString &scheme);
    QString scheme() const;

    void setAuthority(const QString &authority);
    QString authority() const;

    void setUserInfo(const QString &userInfo);
    QString userInfo() const;

    void setUserName(const QString &userName);
    QString userName() const;

    void setPassword(const QString &password);
    QString password() const;

    void setHost(const QString &host);
    QString host() const;

    void setPort(int port);
    int port() const;
    int port(int defaultPort) const;
    

    void setPath(const QString &path);
    QString path() const;

    void setEncodedQuery(const QByteArray &query);
    QByteArray encodedQuery() const;

    void setQueryDelimiters(char valueDelimiter, char pairDelimiter);
    char queryValueDelimiter() const;
    char queryPairDelimiter() const;

    void setQueryItems(const QList<QPair<QString, QString> > &query);
    void addQueryItem(const QString &key, const QString &value);
    QList<QPair<QString, QString> > queryItems() const;
    bool hasQueryItem(const QString &key) const;
    QString queryItemValue(const QString &key) const;
    QStringList allQueryItemValues(const QString &key) const;
    void removeQueryItem(const QString &key);
    void removeAllQueryItems(const QString &key);

    void setFragment(const QString &fragment);
    QString fragment() const;

    QUrl resolved(const QUrl &relative) const;

    bool isRelative() const;
    bool isParentOf(const QUrl &url) const;

    static QUrl fromLocalFile(const QString &localfile);
    QString toLocalFile() const;

    QString toString(FormattingOptions options = None) const;

    QByteArray toEncoded(FormattingOptions options = None) const;
    static QUrl fromEncoded(const QByteArray &url);
    static QUrl fromEncoded(const QByteArray &url, ParsingMode mode);
    

    void detach();
    bool isDetached() const;

    bool operator <(const QUrl &url) const;
    bool operator ==(const QUrl &url) const;
    bool operator !=(const QUrl &url) const;

    static QString fromPercentEncoding(const QByteArray &);
    static QByteArray toPercentEncoding(const QString &,
                                        const QByteArray &exclude = QByteArray(),
                                        const QByteArray &include = QByteArray());
    static QString fromPunycode(const QByteArray &);
    static QByteArray toPunycode(const QString &);


    inline  QString protocol() const { return scheme(); }
    inline  void setProtocol(const QString &s) { setScheme(s); }
    inline  void setUser(const QString &s) { setUserName(s); }
    inline  QString user() const { return userName(); }
    inline  bool hasUser() const { return !userName().isEmpty(); }
    inline  bool hasPassword() const { return !password().isEmpty(); }
    inline  bool hasHost() const { return !host().isEmpty(); }
    inline  bool hasPort() const { return port() != -1; }
    inline  bool hasPath() const { return !path().isEmpty(); }
    inline  void setQuery(const QString &txt)
    {
        setEncodedQuery(txt.toLatin1());
    }
    inline  QString query() const
    {
        return QString::fromLatin1(encodedQuery());
    }
    inline  QString ref() const { return fragment(); }
    inline  void setRef(const QString &txt) { setFragment(txt); }
    inline  bool hasRef() const { return !fragment().isEmpty(); }
    inline  void addPath(const QString &p) { setPath(path() + QLatin1String("/") + p); }
     void setFileName(const QString &txt);
     QString fileName() const;
     QString dirPath() const;
    static inline  void decode(QString &url)
    {
        url = QUrl::fromPercentEncoding(url.toLatin1());
    }
    static inline  void encode(QString &url)
    {
        url = QString::fromLatin1(QUrl::toPercentEncoding(url));
    }
    inline  operator QString() const { return toString(); }
    inline  bool cdUp()
    {
        *this = resolved(QUrl(QLatin1String("..")));
        return true;
    }
    static inline  bool isRelativeUrl(const QString &url)
    {
        return QUrl(url).isRelative();
    }


protected:

    inline  void reset() { clear(); }


private:
    QUrlPrivate *d;
};

template <> class QTypeInfo<QUrl> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QUrl)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QUrl"; } };
template <> inline bool qIsDetached<QUrl>(QUrl &t) { return t . isDetached(); }
inline QFlags<QUrl::FormattingOptions::enum_type> operator|(QUrl::FormattingOptions::enum_type f1, QUrl::FormattingOptions::enum_type f2) { return QFlags<QUrl::FormattingOptions::enum_type>(f1) | f2; } inline QFlags<QUrl::FormattingOptions::enum_type> operator|(QUrl::FormattingOptions::enum_type f1, QFlags<QUrl::FormattingOptions::enum_type> f2) { return f2 | f1; }


 QDataStream &operator<<(QDataStream &, const QUrl &);
 QDataStream &operator>>(QDataStream &, QUrl &);



 QDebug operator<<(QDebug, const QUrl &);




#line 2 "../../include/QtCore/qurl.h"
#line 49 "../../include/QtGui/private/../../../src/gui/text/qtextdocument_p.h"







class QTextFormatCollection;
class QTextFormat;
class QTextBlockFormat;
class QTextCursorPrivate;
class QAbstractTextDocumentLayout;
class QTextDocument;
class QTextFrame;




struct QTextDocumentConfig
{
    QString title;
};

class QTextFragmentData : public QFragment
{
public:
    inline void initialize() {}
    inline void invalidate() const {}
    inline void free() {}
    int stringPosition;
    int format;
};

class QTextBlockData : public QFragment
{
public:
    inline void initialize()
    { layout = 0; userData = 0; userState = -1; }
    void invalidate() const;
    inline void free()
    { delete layout; delete userData; }

    mutable int format;
    
    mutable QTextLayout *layout;
    mutable QTextBlockUserData *userData;
    mutable int userState;
};


class QAbstractUndoItem;

class QTextUndoCommand
{
public:
    enum Command {
        Inserted = 0,
        Removed = 1,
        CharFormatChanged = 2,
        BlockFormatChanged = 3,
        BlockInserted = 4,
        BlockRemoved = 5,
        BlockAdded = 6,
        BlockDeleted = 7,
        GroupFormatChange = 8,
        Custom = 256
    };
    enum Operation {
        KeepCursor = 0,
        MoveCursor = 1
    };
    quint16 command;
    quint8 block;
    quint8 operation;
    int format;
    quint32 strPos;
    quint32 pos;
    union {
        int blockFormat;
        quint32 length;
        QAbstractUndoItem *custom;
        int objectIndex;
    };

    bool tryMerge(const QTextUndoCommand &other);
};
template <> class QTypeInfo<QTextUndoCommand> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextUndoCommand)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextUndoCommand"; } };

class QTextDocumentPrivate : public QObjectPrivate
{
    inline QTextDocument* q_func() { return static_cast<QTextDocument * >(q_ptr); } inline const QTextDocument* q_func() const { return static_cast<const QTextDocument * >(q_ptr); } friend class QTextDocument;
public:
    typedef QFragmentMap<QTextFragmentData> FragmentMap;
    typedef FragmentMap::ConstIterator FragmentIterator;
    typedef QFragmentMap<QTextBlockData> BlockMap;

    QTextDocumentPrivate();
    ~QTextDocumentPrivate();

    void init();
    void clear();

    void setLayout(QAbstractTextDocumentLayout *layout);

    void insert(int pos, const QString &text, int format);
    void insert(int pos, int strPos, int strLength, int format);
    void insertBlock(int pos, int blockFormat, int charFormat, QTextUndoCommand::Operation = QTextUndoCommand::MoveCursor);
    void insertBlock(const QChar &blockSeparator, int pos, int blockFormat, int charFormat,
                     QTextUndoCommand::Operation op = QTextUndoCommand::MoveCursor);

    void remove(int pos, int length, QTextUndoCommand::Operation = QTextUndoCommand::MoveCursor);

    QTextFrame *insertFrame(int start, int end, const QTextFrameFormat &format);
    void removeFrame(QTextFrame *frame);

    enum FormatChangeMode { MergeFormat, SetFormat };

    void setCharFormat(int pos, int length, const QTextCharFormat &newFormat, FormatChangeMode mode = SetFormat);
    void setBlockFormat(const QTextBlock &from, const QTextBlock &to,
			const QTextBlockFormat &newFormat, FormatChangeMode mode = SetFormat);

    void undoRedo(bool undo);
    inline void undo() { undoRedo(true); }
    inline void redo() { undoRedo(false); }
    void appendUndoItem(QAbstractUndoItem *);
    inline void beginEditBlock() { editBlock++; }
    void joinPreviousEditBlock();
    void endEditBlock();
    void enableUndoRedo(bool enable);
    inline bool isUndoRedoEnabled() const { return undoEnabled; }

    inline bool isUndoAvailable() const { return undoEnabled && undoState > 0; }
    inline bool isRedoAvailable() const { return undoEnabled && undoState < undoStack.size(); }

    inline QString buffer() const { return text; }
    QString plainText() const;
    inline int length() const { return fragments.length(); }

    inline QTextFormatCollection *formatCollection() { return &formats; }
    inline const QTextFormatCollection *formatCollection() const { return &formats; }
    inline QAbstractTextDocumentLayout *layout() const { return lout; }

    inline FragmentIterator find(int pos) const { return fragments.find(pos); }
    inline FragmentIterator begin() const { return fragments.begin(); }
    inline FragmentIterator end() const { return fragments.end(); }

    inline QTextBlock blocksBegin() const { return QTextBlock(const_cast<QTextDocumentPrivate *>(this), blocks.firstNode()); }
    inline QTextBlock blocksEnd() const { return QTextBlock(const_cast<QTextDocumentPrivate *>(this), 0); }
    inline QTextBlock blocksFind(int pos) const { return QTextBlock(const_cast<QTextDocumentPrivate *>(this), blocks.findNode(pos)); }
    int blockCharFormatIndex(int node) const;

    inline int numBlocks() const { return blocks.numNodes(); }

    const BlockMap &blockMap() const { return blocks; }
    const FragmentMap &fragmentMap() const { return fragments; }

    static const QTextBlockData *block(const QTextBlock &it) { return it.p->blocks.fragment(it.n); }

    inline QTextDocumentConfig *config() { return &docConfig; }
    inline const QTextDocumentConfig *config() const { return &docConfig; }

    int nextCursorPosition(int position, QTextLayout::CursorMode mode) const;
    int previousCursorPosition(int position, QTextLayout::CursorMode mode) const;

    void changeObjectFormat(QTextObject *group, int format);

    void setModified(bool m);
    inline bool isModified() const { return modified; }

    inline QFont defaultFont() const { return formats.defaultFont(); }
    inline void setDefaultFont(const QFont &f) { formats.setDefaultFont(f); }

private:
    bool split(int pos);
    bool unite(uint f);
    void truncateUndoStack();

    void insert_string(int pos, uint strPos, uint length, int format, QTextUndoCommand::Operation op);
    void insert_block(int pos, uint strPos, int format, int blockformat, QTextUndoCommand::Operation op, int command);
    int remove_string(int pos, uint length, QTextUndoCommand::Operation op);
    int remove_block(int pos, int *blockformat, int command, QTextUndoCommand::Operation op);

    void insert_frame(QTextFrame *f);
    void scan_frames(int pos, int charsRemoved, int charsAdded);
    static void clearFrame(QTextFrame *f);

    void adjustDocumentChangesAndCursors(int from, int addedOrRemoved, QTextUndoCommand::Operation op);

public:
    void documentChange(int from, int length);

    inline void addCursor(QTextCursorPrivate *c) { cursors.append(c); }
    inline void removeCursor(QTextCursorPrivate *c) { cursors.removeAll(c); changedCursors.removeAll(c); }

    QTextFrame *frameAt(int pos) const;
    QTextFrame *rootFrame() const { return frame; }

    QTextObject *objectForIndex(int objectIndex) const;
    QTextObject *objectForFormat(int formatIndex) const;
    QTextObject *objectForFormat(const QTextFormat &f) const;

    QTextObject *createObject(const QTextFormat &newFormat, int objectIndex = -1);
    void deleteObject(QTextObject *object);

    QTextDocument *document() { return q_func(); }
    const QTextDocument *document() const { return q_func(); }

private:
    QTextDocumentPrivate(const QTextDocumentPrivate& m);
    QTextDocumentPrivate& operator= (const QTextDocumentPrivate& m);

    void appendUndoItem(const QTextUndoCommand &c);

    void contentsChanged();

    QString text;

    QVector<QTextUndoCommand> undoStack;
    bool undoEnabled;
    int undoState;
    
    int modifiedState;
    bool modified;

    int editBlock;
    int docChangeFrom;
    int docChangeOldLength;
    int docChangeLength;
    bool framesDirty;

    QTextFormatCollection formats;
    QTextFrame *frame;
    QAbstractTextDocumentLayout *lout;
    FragmentMap fragments;
    BlockMap blocks;
    int initialBlockCharFormatIndex;

    QList<QTextCursorPrivate*> cursors;
    QList<QTextCursorPrivate*> changedCursors;
    QMap<int, QTextObject *> objects;
    QMap<QUrl, QVariant> resources;
    QMap<QUrl, QVariant> cachedResources;

    QTextDocumentConfig docConfig;
    bool useDesignMetrics;

public:
    bool inContentsChange;
    QSizeF pageSize;
};

class QTextTable;
class QTextHtmlExporter
{
public:
    QTextHtmlExporter(const QTextDocument *_doc);

    QString toHtml(const QByteArray &encoding);

    void setFragmentMarkers(bool enable) { fragmentMarkers = enable; }

private:
    enum StyleMode { EmitStyleTag, OmitStyleTag };

    void emitFrame(QTextFrame::Iterator frameIt);
    void emitBlock(const QTextBlock &block);
    void emitTable(const QTextTable *table);
    void emitFragment(const QTextFragment &fragment);

    void emitBlockAttributes(const QTextBlock &block);
    bool emitCharFormatStyle(const QTextCharFormat &format);
    bool emitLogicalFontSize(const QTextCharFormat &format);
    void emitTextLength(const char *attribute, const QTextLength &length);
    void emitAlignment(Qt::Alignment alignment);
    void emitFloatStyle(QTextFrameFormat::Position pos, StyleMode mode = EmitStyleTag);
    void emitMargins(const QString &top, const QString &bottom, const QString &left, const QString &right);
    void emitAttribute(const char *attribute, const QString &value);

    QString html;
    QTextCharFormat defaultCharFormat;
    const QTextDocument *doc;
    bool fragmentMarkers;
};

#line 2 "../../include/QtGui/private/qtextdocument_p.h"
#line 47 "text/qtextengine_p.h"
#line 1 "../../include/QtCore/qset.h"
#line 48 "text/qtextengine_p.h"

#line 1 "/usr/include/assert.h"










  



#ident	"@(#)unixsrc:usr/src/common/head/assert.h /main/1"












extern "C" int __assert(const char *, const char *, int);



#line 39 "/usr/include/assert.h"

#line 52 "text/qtextengine_p.h"


class QFontPrivate;
class QFontEngine;

class QString;
class QOpenType;
class QPainter;

class QAbstractTextDocumentLayout;

struct QFixed {
public:
    QFixed() : val(0) {}
    QFixed(int i) : val(i<<6) {}
    QFixed(long i) : val(i<<6) {}
    QFixed &operator=(int i) { val = (i<<6); return *this; }
    QFixed &operator=(long i) { val = (i<<6); return *this; }

    static QFixed fromReal(qreal r) { QFixed f; f.val = (int)(r*qreal(64)); return f; }
    static QFixed fromFixed(int fixed) { QFixed f; f.val = fixed; return f; }

    inline int value() const { return val; }
    inline void setValue(int value) { val = value; }

    inline int toInt() const { return (((val)+32) & -64)>>6; }
    inline qreal toReal() const { return ((qreal)val)/(qreal)64; }

    inline int truncate() const { return val>>6; }
    inline QFixed round() const { QFixed f; f.val = ((val)+32) & -64; return f; }
    inline QFixed floor() const { QFixed f; f.val = (val) & -64; return f; }
    inline QFixed ceil() const { QFixed f; f.val = (val+63) & -64; return f; }

    inline QFixed operator+(int i) const { QFixed f; f.val = (val + (i<<6)); return f; }
    inline QFixed operator+(uint i) const { QFixed f; f.val = (val + (i<<6)); return f; }
    inline QFixed operator+(const QFixed &other) const { QFixed f; f.val = (val + other.val); return f; }
    inline QFixed &operator+=(int i) { val += (i<<6); return *this; }
    inline QFixed &operator+=(uint i) { val += (i<<6); return *this; }
    inline QFixed &operator+=(const QFixed &other) { val += other.val; return *this; }
    inline QFixed operator-(int i) const { QFixed f; f.val = (val - (i<<6)); return f; }
    inline QFixed operator-(uint i) const { QFixed f; f.val = (val - (i<<6)); return f; }
    inline QFixed operator-(const QFixed &other) const { QFixed f; f.val = (val - other.val); return f; }
    inline QFixed &operator-=(int i) { val -= (i<<6); return *this; }
    inline QFixed &operator-=(uint i) { val -= (i<<6); return *this; }
    inline QFixed &operator-=(const QFixed &other) { val -= other.val; return *this; }
    inline QFixed operator-() const { QFixed f; f.val = -val; return f; }

    inline bool operator==(const QFixed &other) const { return val == other.val; }
    inline bool operator!=(const QFixed &other) const { return val != other.val; }
    inline bool operator<(const QFixed &other) const { return val < other.val; }
    inline bool operator>(const QFixed &other) const { return val > other.val; }
    inline bool operator<=(const QFixed &other) const { return val <= other.val; }
    inline bool operator>=(const QFixed &other) const { return val >= other.val; }
    inline bool operator!() const { return !val; }

    inline QFixed &operator/=(int x) { val /= x; return *this; }
    inline QFixed &operator/=(const QFixed &o) {
        if (o.val == 0) {
            val = 0x7FFFFFFFL;
        } else {
            bool neg = false;
            qint64 a = val;
            qint64 b = o.val;
            if (a < 0) { a = -a; neg = true; }
            if (b < 0) { b = -b; neg = !neg; }

            int res = (int)(((a << 6) + (b >> 1)) / b);

            val = (neg ? -res : res);
        }
        return *this;
    }
    inline QFixed operator/(int d) const { QFixed f; f.val = val/d; return f; }
    inline QFixed operator/(QFixed b) const { QFixed f = *this; return (f /= b); }
    inline QFixed operator>>(int d) const { QFixed f = *this; f.val >>= d; return f; }
    inline QFixed &operator*=(int i) { val *= i; return *this; }
    inline QFixed &operator*=(uint i) { val *= i; return *this; }
    inline QFixed &operator*=(const QFixed &o) {
        bool neg = false;
        qint64 a = val;
        qint64 b = o.val;
        if (a < 0) { a = -a; neg = true; }
        if (b < 0) { b = -b; neg = !neg; }

        int res = (int)((a * b + 0x20L) >> 6);
        val = neg ? -res : res;
        return *this;
    }
    inline QFixed operator*(int i) const { QFixed f = *this; return (f *= i); }
    inline QFixed operator*(uint i) const { QFixed f = *this; return (f *= i); }
    inline QFixed operator*(const QFixed &o) const { QFixed f = *this; return (f *= o); }

private:
    QFixed(qreal i) : val((int)(i*qreal(64))) {}
    QFixed &operator=(qreal i) { val = (int)(i*qreal(64)); return *this; }
    inline QFixed operator+(qreal i) const { QFixed f; f.val = (val + (int)(i*qreal(64))); return f; }
    inline QFixed &operator+=(qreal i) { val += (int)(i*64); return *this; }
    inline QFixed operator-(qreal i) const { QFixed f; f.val = (val - (int)(i*qreal(64))); return f; }
    inline QFixed &operator-=(qreal i) { val -= (int)(i*64); return *this; }
    inline QFixed &operator/=(qreal r) { val = (int)(val/r); return *this; }
    inline QFixed operator/(qreal d) const { QFixed f; f.val = (int)(val/d); return f; }
    inline QFixed &operator*=(qreal d) { val = (int) (val*d); return *this; }
    inline QFixed operator*(qreal d) const { QFixed f = *this; return (f *= d); }
    int val;
};
template <> class QTypeInfo<QFixed> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QFixed)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QFixed"; } };

inline int qRound(const QFixed &f) { return f.toInt(); }

inline QFixed operator*(int i, const QFixed &d) { return d*i; }
inline QFixed operator+(int i, const QFixed &d) { return d+i; }
inline QFixed operator-(int i, const QFixed &d) { return -(d-i); } 
inline QFixed operator*(uint i, const QFixed &d) { return d*i; }
inline QFixed operator+(uint i, const QFixed &d) { return d+i; }
inline QFixed operator-(uint i, const QFixed &d) { return -(d-i); }


inline bool operator==(const QFixed &f, int i) { return f.value() == (i<<6); }
inline bool operator==(int i, const QFixed &f) { return f.value() == (i<<6); }
inline bool operator!=(const QFixed &f, int i) { return f.value() != (i<<6); }
inline bool operator!=(int i, const QFixed &f) { return f.value() != (i<<6); }
inline bool operator<=(const QFixed &f, int i) { return f.value() <= (i<<6); }
inline bool operator<=(int i, const QFixed &f) { return (i<<6) <= f.value(); }
inline bool operator>=(const QFixed &f, int i) { return f.value() >= (i<<6); }
inline bool operator>=(int i, const QFixed &f) { return (i<<6) >= f.value(); }
inline bool operator<(const QFixed &f, int i) { return f.value() < (i<<6); }
inline bool operator<(int i, const QFixed &f) { return (i<<6) < f.value(); }
inline bool operator>(const QFixed &f, int i) { return f.value() > (i<<6); }
inline bool operator>(int i, const QFixed &f) { return (i<<6) > f.value(); }

struct QFixedPoint {
    QFixed x;
    QFixed y;
    QPointF toPointF() const { return QPointF(x.toReal(), y.toReal()); }
};


class QTextItemInt : public QTextItem
{
public:
    inline QTextItemInt() : flags(0) {}
    QFixed descent;
    QFixed ascent;
    QFixed width;

    RenderFlags flags;
    int num_chars;
    const QChar *chars;
    const unsigned short *logClusters;
    const QFont *f;
    QColor underlineColor;

    QGlyphLayout *glyphs;
    int num_glyphs;
    QFontEngine *fontEngine;
};







struct glyph_metrics_t
{
    inline glyph_metrics_t()
        : x(100000),  y(100000) {}
    inline glyph_metrics_t(QFixed _x, QFixed _y, QFixed _width, QFixed _height, QFixed _xoff, QFixed _yoff)
        : x(_x),
          y(_y),
          width(_width),
          height(_height),
          xoff(_xoff),
          yoff(_yoff)
        {}
    QFixed x;
    QFixed y;
    QFixed width;
    QFixed height;
    QFixed xoff;
    QFixed yoff;
};
template <> class QTypeInfo<glyph_metrics_t> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(glyph_metrics_t)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "glyph_metrics_t"; } };

typedef unsigned int glyph_t;




struct QScriptAnalysis
{
    unsigned short script    : 7;
    unsigned short override  : 1;  
    unsigned short bidiLevel : 6;  
    unsigned short reserved  : 2;
    bool operator == (const QScriptAnalysis &other) {
        return
            script == other.script &&
            bidiLevel == other.bidiLevel;
        

    }

};
template <> class QTypeInfo<QScriptAnalysis> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QScriptAnalysis)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QScriptAnalysis"; } };

#line 292 "text/qtextengine_p.h"

struct QGlyphLayout
{
    inline QGlyphLayout()
        : glyph(0), justificationType(0), nKashidas(0), space_18d6(0)
        {}

    
    
    
    
    enum Justification {
        NoJustification= 0,   
        Arabic_Space   = 1,   
        Character      = 2,   
        Space          = 4,   
        Arabic_Normal  = 7,   
        Arabic_Waw     = 8,    
        Arabic_BaRa    = 9,   
        Arabic_Alef    = 10,  
        Arabic_HaaDal  = 11,  
        Arabic_Seen    = 12,  
        Arabic_Kashida = 13   
    };

    glyph_t glyph;
    struct Attributes {
        unsigned short justification   :4;  
        unsigned short clusterStart    :1;  
        unsigned short mark            :1;  
        unsigned short zeroWidth       :1;  
        unsigned short dontPrint       :1;
        unsigned short combiningClass  :8;
    };
    Attributes attributes;
    QFixedPoint advance;
    QFixedPoint offset;

    enum JustificationType {
        JustifyNone,
        JustifySpace,
        JustifyKashida
    };
    uint justificationType :2;
    uint nKashidas : 6; 
    uint space_18d6 : 24;
};
template <> class QTypeInfo<QGlyphLayout> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QGlyphLayout)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QGlyphLayout"; } };

inline bool qIsControlChar(ushort uc)
{
    return (uc >= 0x200b && uc <= 0x200f  )
            || (uc >= 0x2028 && uc <= 0x202f  )
            || (uc >= 0x206a && uc <= 0x206f  );
}


struct QCharAttributes {
    uchar softBreak      :1;     
    uchar whiteSpace     :1;     
    uchar charStop       :1;     
    uchar category       :5;
};
template <> class QTypeInfo<QCharAttributes> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QCharAttributes)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QCharAttributes"; } };

struct QScriptItem
{
    inline QScriptItem() : position(0), isSpace(false), isTab(false),
                           isObject(false),
                           num_glyphs(0), descent(-1), ascent(-1), width(-1),
                           glyph_data_offset(0) {}

    int position;
    QScriptAnalysis analysis;
    unsigned short isSpace  : 1;
    unsigned short isTab    : 1;
    unsigned short isObject : 1;
    int num_glyphs;
    QFixed descent;
    QFixed ascent;
    QFixed width;
    int glyph_data_offset;
    QFixed height() const { return ascent + descent; }
};


template <> class QTypeInfo<QScriptItem> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QScriptItem)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QScriptItem"; } };

typedef QVector<QScriptItem> QScriptItemArray;

struct QScriptLine
{
    QScriptLine()
        : from(0), length(0),
        justified(0), gridfitted(0) {}
    QFixed descent;
    QFixed ascent;
    QFixed x;
    QFixed y;
    QFixed width;
    QFixed textWidth;
    int from;
    signed int length : 30;
    mutable uint justified : 1;
    mutable uint gridfitted : 1;
    QFixed height() const { return ascent + descent + 1; }
    void setDefaultHeight(QTextEngine *eng);
    void operator+=(const QScriptLine &other);
};
template <> class QTypeInfo<QScriptLine> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QScriptLine)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QScriptLine"; } };


inline void QScriptLine::operator+=(const QScriptLine &other)
{
    descent = qMax(descent, other.descent);
    ascent = qMax(ascent, other.ascent);
    textWidth += other.textWidth;
    length += other.length;
}

typedef QVector<QScriptLine> QScriptLineArray;

class QFontPrivate;
class QTextFormatCollection;

class  QTextEngine {
public:
    struct LayoutData {
        LayoutData(const QString &str, void **stack_memory, int mem_size);
        LayoutData();
        ~LayoutData();
        mutable QScriptItemArray items;
        int allocated;
        int available_glyphs;
        void **memory;
        unsigned short *logClustersPtr;
        QGlyphLayout *glyphPtr;
        int num_glyphs;
        mutable int used;
        uint hasBidi : 1;
        uint inLayout : 1;
        uint memory_on_stack : 1;
        bool haveCharAttributes;
        QString string;
        void reallocate(int totalGlyphs);
    };

    QTextEngine(LayoutData *data);
    QTextEngine();
    QTextEngine(const QString &str, const QFont &f);
    ~QTextEngine();

    enum Mode {
        WidthOnly = 0x07
    };

    enum ShaperFlag {
        RightToLeft = 0x0001,
        Mirrored = 0x0001,
        DesignMetrics = 0x0002,
        GlyphIndicesOnly = 0x0004
    };
    typedef QFlags<ShaperFlag> ShaperFlags;

    void invalidate();

    void validate() const;
    void itemize() const;

    static void bidiReorder(int numRuns, const quint8 *levels, int *visualOrder);

    const QCharAttributes *attributes() const;

    void shape(int item) const;

    void justify(const QScriptLine &si);

    QFixed width(int charFrom, int numChars) const;
    glyph_metrics_t boundingBox(int from,  int len) const;

    int length(int item) const {
        const QScriptItem &si = layoutData->items[item];
        int from = si.position;
        item++;
        return (item < layoutData->items.size() ? layoutData->items[item].position : layoutData->string.length()) - from;
    }
    int length(const QScriptItem *si) const {
        int end;
        if (si + 1 < layoutData->items.constData()+ layoutData->items.size())
            end = (si+1)->position;
        else
            end = layoutData->string.length();
        return end - si->position;
    }

    QFontEngine *fontEngine(const QScriptItem &si, QFixed *ascent = 0, QFixed *descent = 0) const;
    QFont font(const QScriptItem &si) const;
    inline QFont font() const { return fnt; }

    inline unsigned short *logClusters(const QScriptItem *si) const
        { return layoutData->logClustersPtr+si->position; }
    inline QGlyphLayout *glyphs(const QScriptItem *si) const
        { return layoutData->glyphPtr + si->glyph_data_offset; }

    inline void ensureSpace(int nGlyphs) const {
        if (layoutData->num_glyphs - layoutData->used < nGlyphs)
            layoutData->reallocate((((layoutData->used + nGlyphs)*3/2 + 15) >> 4) << 4);
    }

    void freeMemory();

    int findItem(int strPos) const;
    inline QTextFormatCollection *formats() const {
        return block.docHandle()->formatCollection();
    }
    QTextCharFormat format(const QScriptItem *si) const;
    inline QAbstractTextDocumentLayout *docLayout() const {
        return block.docHandle()->document()->documentLayout();
    }
    int formatIndex(const QScriptItem *si) const;

    QFixed nextTab(const QScriptItem *si, QFixed x) const;

    mutable QScriptLineArray lines;

    QString text;
    QFont fnt;
    QTextBlock block;

    QTextOption option;

    QFixed minWidth;
    QFixed maxWidth;
    QPointF position;
    uint ignoreBidi : 1;
    uint cacheGlyphs : 1;
    uint stackEngine : 1;

    int *underlinePositions;

    mutable LayoutData *layoutData;

    inline bool hasFormats() const { return (block.docHandle() || specialData); }

    struct SpecialData {
        int preeditPosition;
        QString preeditText;
        QList<QTextLayout::FormatRange> addFormats;
        QVector<int> addFormatIndices;
        QVector<int> resolvedFormatIndices;
    };
    SpecialData *specialData;

    bool atWordSeparator(int position) const;
    void indexAdditionalFormats();

private:
    void setBoundary(int strPos) const;
    void addRequiredBoundaries() const;
    void shapeText(int item) const;
    void splitItem(int item, int pos) const;

    void resolveAdditionalFormats() const;
};

class QStackTextEngine : public QTextEngine {
public:
    enum { MemSize = 256*40/sizeof(void *) };
    QStackTextEngine(const QString &string, const QFont &f);
    LayoutData _layoutData;
    void *_memory[MemSize];
};


inline QFlags<QTextEngine::ShaperFlags::enum_type> operator|(QTextEngine::ShaperFlags::enum_type f1, QTextEngine::ShaperFlags::enum_type f2) { return QFlags<QTextEngine::ShaperFlags::enum_type>(f1) | f2; } inline QFlags<QTextEngine::ShaperFlags::enum_type> operator|(QTextEngine::ShaperFlags::enum_type f1, QFlags<QTextEngine::ShaperFlags::enum_type> f2) { return f2 | f1; }



#line 26 "text/qtextengine.cpp"
#line 1 "text/qabstracttextdocumentlayout.h"



















 




#line 1 "../../include/QtCore/qobject.h"
#line 26 "text/qabstracttextdocumentlayout.h"
#line 1 "../../include/QtGui/qtextlayout.h"
#line 27 "text/qabstracttextdocumentlayout.h"
#line 1 "../../include/QtGui/qtextdocument.h"
#line 28 "text/qabstracttextdocumentlayout.h"
#line 1 "../../include/QtGui/qtextcursor.h"
#line 1 "../../include/QtGui/../../src/gui/text/qtextcursor.h"



















 




#line 1 "../../include/QtCore/qstring.h"
#line 26 "../../include/QtGui/../../src/gui/text/qtextcursor.h"
#line 1 "../../include/QtCore/qshareddata.h"
#line 27 "../../include/QtGui/../../src/gui/text/qtextcursor.h"
#line 1 "../../include/QtGui/qtextformat.h"
#line 28 "../../include/QtGui/../../src/gui/text/qtextcursor.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QTextDocument;
class QTextCursorPrivate;
class QTextDocumentFragment;
class QTextCharFormat;
class QTextBlockFormat;
class QTextListFormat;
class QTextTableFormat;
class QTextFrameFormat;
class QTextImageFormat;
class QTextDocumentPrivate;
class QTextList;
class QTextTable;
class QTextFrame;
class QTextBlock;

class  QTextCursor
{
public:
    QTextCursor();
    explicit QTextCursor(QTextDocument *document);
    QTextCursor(QTextDocumentPrivate *p, int pos);
    explicit QTextCursor(QTextFrame *frame);
    explicit QTextCursor(const QTextBlock &block);
    explicit QTextCursor(QTextCursorPrivate *d);
    QTextCursor(const QTextCursor &cursor);
    QTextCursor &operator=(const QTextCursor &other);
    ~QTextCursor();

    bool isNull() const;

    enum MoveMode {
        MoveAnchor,
        KeepAnchor
    };

    void setPosition(int pos, MoveMode mode = MoveAnchor);
    int position() const;

    int anchor() const;

    void insertText(const QString &text);
    void insertText(const QString &text, const QTextCharFormat &format);

    enum MoveOperation {
        NoMove,

        Start,
        Up,
        StartOfLine,
        StartOfBlock,
        StartOfWord,
        PreviousBlock,
        PreviousCharacter,
        PreviousWord,
        Left,
        WordLeft,

        End,
        Down,
        EndOfLine,
        EndOfWord,
        EndOfBlock,
        NextBlock,
        NextCharacter,
        NextWord,
        Right,
        WordRight
    };

    bool movePosition(MoveOperation op, MoveMode = MoveAnchor, int n = 1);

    void deleteChar();
    void deletePreviousChar();

    enum SelectionType {
        WordUnderCursor,
        LineUnderCursor,
        BlockUnderCursor
    };
    void select(SelectionType selection);

    bool hasSelection() const;
    bool hasComplexSelection() const;
    void removeSelectedText();
    void clearSelection();
    int selectionStart() const;
    int selectionEnd() const;

    QString selectedText() const;
    QTextDocumentFragment selection() const;
    void selectedTableCells(int *firstRow, int *numRows, int *firstColumn, int *numColumns) const;

    QTextBlock block() const;

    QTextCharFormat charFormat() const;
    void setCharFormat(const QTextCharFormat &format);
    void mergeCharFormat(const QTextCharFormat &modifier);

    QTextBlockFormat blockFormat() const;
    void setBlockFormat(const QTextBlockFormat &format);
    void mergeBlockFormat(const QTextBlockFormat &modifier);

    QTextCharFormat blockCharFormat() const;
    void setBlockCharFormat(const QTextCharFormat &format);
    void mergeBlockCharFormat(const QTextCharFormat &modifier);

    bool atBlockStart() const;
    bool atBlockEnd() const;
    bool atStart() const;
    bool atEnd() const;

    void insertBlock();
    void insertBlock(const QTextBlockFormat &format);
    void insertBlock(const QTextBlockFormat &format, const QTextCharFormat &charFormat);

    QTextList *insertList(const QTextListFormat &format);
    QTextList *insertList(QTextListFormat::Style style);

    QTextList *createList(const QTextListFormat &format);
    QTextList *createList(QTextListFormat::Style style);
    QTextList *currentList() const;

    QTextTable *insertTable(int rows, int cols, const QTextTableFormat &format);
    QTextTable *insertTable(int rows, int cols);
    QTextTable *currentTable() const;

    QTextFrame *insertFrame(const QTextFrameFormat &format);
    QTextFrame *currentFrame() const;

    void insertFragment(const QTextDocumentFragment &fragment);

    void insertImage(const QTextImageFormat &format);
    void insertImage(const QString &name);

    void beginEditBlock();
    void joinPreviousEditBlock();
    void endEditBlock();

    bool operator!=(const QTextCursor &rhs) const;
    bool operator<(const QTextCursor &rhs) const;
    bool operator<=(const QTextCursor &rhs) const;
    bool operator==(const QTextCursor &rhs) const;
    bool operator>=(const QTextCursor &rhs) const;
    bool operator>(const QTextCursor &rhs) const;

    bool isCopyOf(const QTextCursor &other) const;

private:
    QSharedDataPointer<QTextCursorPrivate> d;
    friend class QTextDocumentFragmentPrivate;
    friend class QTextCopyHelper;
};



#line 2 "../../include/QtGui/qtextcursor.h"
#line 29 "text/qabstracttextdocumentlayout.h"
#line 1 "../../include/QtGui/qpalette.h"
#line 1 "../../include/QtGui/../../src/gui/kernel/qpalette.h"



















 




#line 1 "../../include/QtGui/qwindowdefs.h"
#line 26 "../../include/QtGui/../../src/gui/kernel/qpalette.h"
#line 1 "../../include/QtGui/qcolor.h"
#line 27 "../../include/QtGui/../../src/gui/kernel/qpalette.h"
#line 1 "../../include/QtGui/qbrush.h"
#line 28 "../../include/QtGui/../../src/gui/kernel/qpalette.h"



typedef QtValidLicenseForGuiModule QtGuiModule;


class QColorGroup;

class QPalettePrivate;
class QVariant;

class  QPalette
{
    public: static const QMetaObject staticMetaObject; private:
    
public:
    QPalette();
    QPalette(const QColor &button);
    QPalette(Qt::GlobalColor button);
    QPalette(const QColor &button, const QColor &window);
    QPalette(const QBrush &windowText, const QBrush &button, const QBrush &light,
             const QBrush &dark, const QBrush &mid, const QBrush &text,
             const QBrush &bright_text, const QBrush &base, const QBrush &window);
    QPalette(const QColor &windowText, const QColor &window, const QColor &light,
             const QColor &dark, const QColor &mid, const QColor &text, const QColor &base);

    explicit QPalette(const QColorGroup &active, const QColorGroup &disabled, const QColorGroup &inactive);

    QPalette(const QPalette &palette);
    ~QPalette();
    QPalette &operator=(const QPalette &palette);
    operator QVariant() const;

    
    enum ColorGroup { Active, Disabled, Inactive, NColorGroups, Current, All, Normal = Active };
    enum ColorRole { WindowText, Button, Light, Midlight, Dark, Mid,
                     Text, BrightText, ButtonText, Base, Window, Shadow,
                     Highlight, HighlightedText, Link, LinkVisited, AlternateBase,
                     NColorRoles, NoRole = NColorRoles
                     
                     , Foreground = WindowText, Background = Window
                   };

    inline ColorGroup currentColorGroup() const { return static_cast<ColorGroup>(current_group); }
    inline void setCurrentColorGroup(ColorGroup cg) { current_group = cg; }

    inline const QColor &color(ColorGroup cg, ColorRole cr) const
    { return brush(cg, cr).color(); }
    const QBrush &brush(ColorGroup cg, ColorRole cr) const;
    inline void setColor(ColorGroup cg, ColorRole cr, const QColor &color);
    inline void setColor(ColorRole cr, const QColor &color);
    inline void setBrush(ColorRole cr, const QBrush &brush);
    void setBrush(ColorGroup cg, ColorRole cr, const QBrush &brush);
    void setColorGroup(ColorGroup cr, const QBrush &windowText, const QBrush &button,
                       const QBrush &light, const QBrush &dark, const QBrush &mid,
                       const QBrush &text, const QBrush &bright_text, const QBrush &base,
                       const QBrush &window);
    bool isEqual(ColorGroup cr1, ColorGroup cr2) const;

    inline const QColor &color(ColorRole cr) const { return color(Current, cr); }
    inline const QBrush &brush(ColorRole cr) const { return brush(Current, cr); }
    inline const QBrush &foreground() const { return brush(Foreground); }
    inline const QBrush &windowText() const { return brush(WindowText); }
    inline const QBrush &button() const { return brush(Button); }
    inline const QBrush &light() const { return brush(Light); }
    inline const QBrush &dark() const { return brush(Dark); }
    inline const QBrush &mid() const { return brush(Mid); }
    inline const QBrush &text() const { return brush(Text); }
    inline const QBrush &base() const { return brush(Base); }
    inline const QBrush &alternateBase() const { return brush(AlternateBase); }
    inline const QBrush &background() const { return brush(Background); }
    inline const QBrush &window() const { return brush(Window); }
    inline const QBrush &midlight() const { return brush(Midlight); }
    inline const QBrush &brightText() const { return brush(BrightText); }
    inline const QBrush &buttonText() const { return brush(ButtonText); }
    inline const QBrush &shadow() const { return brush(Shadow); }
    inline const QBrush &highlight() const { return brush(Highlight); }
    inline const QBrush &highlightedText() const { return brush(HighlightedText); }
    inline const QBrush &link() const { return brush(Link); }
    inline const QBrush &linkVisited() const { return brush(LinkVisited); }


    inline  QPalette copy() const { QPalette p = *this; p.detach(); return p; }
     QColorGroup normal() const;
    inline  void setNormal(const QColorGroup &cg) { setColorGroup(Active, cg); }

     QColorGroup active() const;
     QColorGroup disabled() const;
     QColorGroup inactive() const;
    inline  void setActive(const QColorGroup &cg) { setColorGroup(Active, cg); }
    inline  void setDisabled(const QColorGroup &cg) { setColorGroup(Disabled, cg); }
    inline  void setInactive(const QColorGroup &cg) { setColorGroup(Inactive, cg); }


    bool operator==(const QPalette &p) const;
    inline bool operator!=(const QPalette &p) const { return !(operator==(p)); }
    bool isCopyOf(const QPalette &p) const;

    int serialNumber() const;

    QPalette resolve(const QPalette &) const;
    inline uint resolve() const { return resolve_mask; }
    inline void resolve(uint mask) { resolve_mask = mask; }

private:
    void setColorGroup(ColorGroup cr, const QBrush &windowText, const QBrush &button,
                       const QBrush &light, const QBrush &dark, const QBrush &mid,
                       const QBrush &text, const QBrush &bright_text,
                       const QBrush &base, const QBrush &alternate_base,
                       const QBrush &window, const QBrush &midlight,
                       const QBrush &button_text, const QBrush &shadow,
                       const QBrush &highlight, const QBrush &highlighted_text,
                       const QBrush &link, const QBrush &link_visited);

    friend class QColorGroup;
    void setColorGroup(ColorGroup, const QColorGroup &);
    QColorGroup createColorGroup(ColorGroup) const;

    void init();
    void detach();

    QPalettePrivate *d;
    uint current_group : 4;
    uint resolve_mask : 28;
    friend  QDataStream &operator<<(QDataStream &s, const QPalette &p);
};

inline void QPalette::setColor(ColorGroup acg, ColorRole acr,
                               const QColor &acolor)
{ setBrush(acg, acr, QBrush(acolor)); }
inline void QPalette::setColor(ColorRole acr, const QColor &acolor)
{ setColor(All, acr, acolor); }
inline void QPalette::setBrush(ColorRole acr, const QBrush &abrush)
{ setBrush(All, acr, abrush); }


class  QColorGroup : public QPalette
{
public:
    inline QColorGroup() : QPalette() {}
    inline QColorGroup(const QBrush &foreground, const QBrush &button, const QBrush &light,
                const QBrush &dark, const QBrush &mid, const QBrush &text,
                const QBrush &bright_text, const QBrush &base, const QBrush &background)
        : QPalette(foreground, button, light, dark, mid, text, bright_text, base, background)
    {}
    inline QColorGroup(const QColor &foreground, const QColor &background, const QColor &light,
                const QColor &dark, const QColor &mid, const QColor &text, const QColor &base)
        : QPalette(foreground, background, light, dark, mid, text, base) {}
    inline QColorGroup(const QColorGroup &cg) : QPalette(cg) {}
    inline QColorGroup(const QPalette &pal) : QPalette(pal) {}
    bool operator==(const QColorGroup &other) const;
    inline bool operator!=(const QColorGroup &other) const { return !(operator==(other)); }
    operator QVariant() const;

    inline  const QColor &foreground() const { return color(Foreground); }
    inline  const QColor &button() const { return color(Button); }
    inline  const QColor &light() const { return color(Light); }
    inline  const QColor &dark() const { return color(Dark); }
    inline  const QColor &mid() const { return color(Mid); }
    inline  const QColor &text() const { return color(Text); }
    inline  const QColor &base() const { return color(Base); }
    inline  const QColor &background() const { return color(Background); }
    inline  const QColor &midlight() const { return color(Midlight); }
    inline  const QColor &brightText() const { return color(BrightText); }
    inline  const QColor &buttonText() const { return color(ButtonText); }
    inline  const QColor &shadow() const { return color(Shadow); }
    inline  const QColor &highlight() const { return color(Highlight); }
    inline  const QColor &highlightedText() const { return color(HighlightedText); }
    inline  const QColor &link() const { return color(Link); }
    inline  const QColor &linkVisited() const { return color(LinkVisited); }
};


  QDataStream &operator<<(QDataStream &ds, const QColorGroup &cg);
  QDataStream &operator>>(QDataStream &ds, QColorGroup &cg);


inline QColorGroup QPalette::inactive() const { return createColorGroup(Inactive); }
inline QColorGroup QPalette::disabled() const { return createColorGroup(Disabled); }
inline QColorGroup QPalette::active() const { return createColorGroup(Active); }
inline QColorGroup QPalette::normal() const { return createColorGroup(Active); }





 

 QDataStream &operator<<(QDataStream &ds, const QPalette &p);
 QDataStream &operator>>(QDataStream &ds, QPalette &p);




#line 2 "../../include/QtGui/qpalette.h"
#line 30 "text/qabstracttextdocumentlayout.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QAbstractTextDocumentLayoutPrivate;
class QTextBlock;
class QTextObjectInterface;
class QTextFrame;

class  QAbstractTextDocumentLayout : public QObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:
    inline QAbstractTextDocumentLayoutPrivate* d_func() { return reinterpret_cast<QAbstractTextDocumentLayoutPrivate * >(d_ptr); } inline const QAbstractTextDocumentLayoutPrivate* d_func() const { return reinterpret_cast<const QAbstractTextDocumentLayoutPrivate * >(d_ptr); } friend class QAbstractTextDocumentLayoutPrivate;

public:
    explicit QAbstractTextDocumentLayout(QTextDocument *doc);
    ~QAbstractTextDocumentLayout();

    struct Selection
    {
        QTextCursor cursor;
        QTextCharFormat format;
    };

    struct PaintContext
    {
        PaintContext()
            : cursorPosition(-1)
            {}
        int cursorPosition;
        QPalette palette;
        QRectF clip;
        QVector<Selection> selections;
    };

    virtual void draw(QPainter *painter, const PaintContext &context) = 0;
    virtual int hitTest(const QPointF &point, Qt::HitTestAccuracy accuracy) const = 0;
    QString anchorAt(const QPointF& pos) const;

    virtual int pageCount() const = 0;
    virtual QSizeF documentSize() const = 0;

    virtual QRectF frameBoundingRect(QTextFrame *frame) const = 0;
    virtual QRectF blockBoundingRect(const QTextBlock &block) const = 0;

    void setPaintDevice(QPaintDevice *device);
    QPaintDevice *paintDevice() const;

    QTextDocument *document() const;

    void registerHandler(int objectType, QObject *component);
    QTextObjectInterface *handlerForObject(int objectType) const;

protected:
    void update(const QRectF & = QRectF(0., 0., 1000000000., 1000000000.));
    void documentSizeChanged(const QSizeF &newSize);
    void pageCountChanged(int newPages);

protected:
    QAbstractTextDocumentLayout(QAbstractTextDocumentLayoutPrivate &, QTextDocument *);

    virtual void documentChanged(int from, int charsRemoved, int charsAdded) = 0;

    virtual void resizeInlineObject(QTextInlineObject item, int posInDocument, const QTextFormat &format);
    virtual void positionInlineObject(QTextInlineObject item, int posInDocument, const QTextFormat &format);
    virtual void drawInlineObject(QPainter *painter, const QRectF &rect, QTextInlineObject object, int posInDocument, const QTextFormat &format);

    int formatIndex(int pos);
    QTextCharFormat format(int pos);

private:
    friend class QTextDocument;
    friend class QTextDocumentPrivate;
    friend class QTextEngine;
    friend class QTextLayout;
    friend class QTextLine;
    
    
    
};

class  QTextObjectInterface
{
public:
    virtual ~QTextObjectInterface() {}
    virtual QSizeF intrinsicSize(QTextDocument *doc, int posInDocument, const QTextFormat &format) = 0;
    virtual void drawObject(QPainter *painter, const QRectF &rect, QTextDocument *doc, int posInDocument, const QTextFormat &format) = 0;
};
template <> inline QTextObjectInterface *qobject_cast<QTextObjectInterface * >(QObject *object) { return reinterpret_cast<QTextObjectInterface * >((object ? object->qt_metacast("com.trolltech.Qt.QTextObjectInterface") : 0)); } template <> inline QTextObjectInterface *qobject_cast<QTextObjectInterface * >(const QObject *object) { return reinterpret_cast<QTextObjectInterface * >((object ? const_cast<QObject * >(object)->qt_metacast("com.trolltech.Qt.QTextObjectInterface") : 0)); }



#line 27 "text/qtextengine.cpp"
#line 1 "../../include/QtCore/qvarlengtharray.h"
#line 1 "../../include/QtCore/../../src/corelib/tools/qvarlengtharray.h"



















 




#line 1 "../../include/QtCore/qglobal.h"
#line 26 "../../include/QtCore/../../src/corelib/tools/qvarlengtharray.h"
#line 1 "/usr/include/CC/new"
#ident	"@(#)unixsrc:usr/src/common/lib/libC/new /main/1"

 


 

#line 27 "../../include/QtCore/../../src/corelib/tools/qvarlengtharray.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

template<class T, int Prealloc = 256>
class QVarLengthArray
{
public:
    inline explicit QVarLengthArray(int size = 0);

    inline QVarLengthArray(const QVarLengthArray<T, Prealloc> &other)
        : a(Prealloc), s(0), ptr(reinterpret_cast<T *>(array))
    {
        append(other.constData(), other.size());
    }

    inline ~QVarLengthArray() {
        if (QTypeInfo<T>::isComplex) {
            T *i = ptr + s;
            while (i-- != ptr)
                i->~T();
        }
        if (ptr != reinterpret_cast<T *>(array))
            qFree(ptr);
    }
    inline QVarLengthArray<T, Prealloc> &operator=(const QVarLengthArray<T, Prealloc> &other)
    {
        if (this != &other) {
            clear();
            append(other.constData(), other.size());
        }
        return *this;
    }

    inline int size() const { return s; }
    inline int count() const { return s; }
    inline bool isEmpty() const { return (s == 0); }
    inline void resize(int size);
    inline void clear() { resize(0); }

    inline int capacity() const { return a; }
    inline void reserve(int size);

    inline T &operator[](int idx) {
        do {if(!(idx >= 0 && idx < s))qt_assert("idx >= 0 && idx < s","../../include/QtCore/../../src/corelib/tools/qvarlengtharray.h",72);} while (0);
        return ptr[idx];
    }
    inline const T &operator[](int idx) const {
        do {if(!(idx >= 0 && idx < s))qt_assert("idx >= 0 && idx < s","../../include/QtCore/../../src/corelib/tools/qvarlengtharray.h",76);} while (0);
        return ptr[idx];
    }

    inline void append(const T &t) {
        const int idx = s;
        resize(idx + 1);
        ptr[idx] = t;
    }
    void append(const T *buf, int size);

    inline T *data() { return ptr; }
    inline const T *data() const { return ptr; }
    inline const T * constData() const { return ptr; }

private:
    void realloc(int size, int alloc);

    int a;
    int s;
    T *ptr;
    qint64 array[((Prealloc * sizeof(T)) / sizeof(qint64)) + 1];
};

template <class T, int Prealloc>
inline QVarLengthArray<T, Prealloc>::QVarLengthArray(int asize)
    : s(asize) {
    if (s > Prealloc) {
        ptr = reinterpret_cast<T *>(qMalloc(s * sizeof(T)));
        a = s;
    } else {
        ptr = reinterpret_cast<T *>(array);
        a = Prealloc;
    }
    if (QTypeInfo<T>::isComplex) {
        T *i = ptr + s;
        while (i != ptr)
            new (--i) T;
    }
}

template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::resize(int asize)
{ realloc(asize, qMax(asize, a)); }

template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::reserve(int asize)
{ if (asize > a) realloc(s, asize); }

template <class T, int Prealloc>
 void QVarLengthArray<T, Prealloc>::append(const T *abuf, int asize)
{
    do {if(!(abuf))qt_assert("abuf","../../include/QtCore/../../src/corelib/tools/qvarlengtharray.h",128);} while (0);
    if (asize <= 0)
        return;

    const int idx = s;
    resize(idx + asize);

    if (QTypeInfo<T>::isComplex) {
        T *i = ptr + idx;
        T *j = i + asize;
        while (i < j)
            new (i++) T(*abuf++);
    } else {
        qMemCopy(&ptr[idx], abuf, asize * sizeof(T));
    }
}

template <class T, int Prealloc>
 void QVarLengthArray<T, Prealloc>::realloc(int asize, int aalloc)
{
    do {if(!(aalloc >= asize))qt_assert("aalloc >= asize","../../include/QtCore/../../src/corelib/tools/qvarlengtharray.h",148);} while (0);
    T *oldPtr = ptr;
    int osize = s;
    s = asize;

    if (aalloc != a) {
        ptr = reinterpret_cast<T *>(qMalloc(aalloc * sizeof(T)));
        a = aalloc;

        if (QTypeInfo<T>::isStatic) {
            T *i = ptr + osize;
            T *j = oldPtr + osize;
            while (i != ptr) {
                new (--i) T(*--j);
                j->~T();
            }
        } else {
            qMemCopy(ptr, oldPtr, osize * sizeof(T));
        }
    }

    if (QTypeInfo<T>::isComplex) {
        if (asize < osize) {
            T *i = oldPtr + osize;
            T *j = oldPtr + asize;
            while (i-- != j)
                i->~T();
        } else {
            T *i = ptr + asize;
            T *j = ptr + osize;
            while (i != j)
                new (--i) T;
        }
    }

    if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr)
        qFree(oldPtr);
}



#line 2 "../../include/QtCore/qvarlengtharray.h"
#line 29 "text/qtextengine.cpp"
#line 1 "text/qscriptengine_p.h"



















 

















class QString;
struct QGlyphLayout;
struct QCharAttributes;

struct QShaperItem {
    int script;
    const QString *string;
    int from;
    int length;
    QFontEngine *font;
    QGlyphLayout *glyphs;
    int num_glyphs; 
    unsigned short *log_clusters;
    int flags;
    const QCharAttributes *charAttributes;
};


typedef bool (*ShapeFunction)(QShaperItem *item);
typedef void (*AttributeFunction)(int script, const QString &, int, int, QCharAttributes *);

struct q_scriptEngine {
    ShapeFunction shape;
    AttributeFunction charAttributes;
};

extern const q_scriptEngine qt_scriptEngines[];

struct QArabicProperties {
    unsigned char shape;
    unsigned char justification;
};
template <> class QTypeInfo<QArabicProperties> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QArabicProperties)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QArabicProperties"; } };

enum QArabicShape {
    XIsolated,
    XFinal,
    XInitial,
    XMedial,
    
    XCausing
};

void qt_getArabicProperties(const unsigned short *chars, int len, QArabicProperties *properties);

#line 30 "text/qtextengine.cpp"
#line 1 "text/qfontengine_p.h"



















 















#line 1 "../../include/QtCore/qglobal.h"
#line 37 "text/qfontengine_p.h"
#line 1 "../../include/QtCore/qatomic.h"
#line 38 "text/qfontengine_p.h"
#line 1 "../../include/QtCore/qvarlengtharray.h"
#line 39 "text/qfontengine_p.h"
#line 1 "../../include/QtGui/private/qtextengine_p.h"
#line 40 "text/qfontengine_p.h"
#line 1 "../../include/QtGui/private/qfont_p.h"
#line 41 "text/qfontengine_p.h"




struct glyph_metrics_t;
class QChar;
typedef unsigned int glyph_t;
class QOpenType;
class QPainterPath;

class QTextEngine;
struct QGlyphLayout;

class QFontEngine
{
public:
    enum Type {
        Box,
        Multi,

        
        XLFD,

        
        Win,

        
        Mac,

        
        Freetype,
        QPF,
        TestFontEngine = 0x1000
    };

    inline QFontEngine() {
        ref = 0;
        cache_count = 0;
        fsType = 0;




    }
    virtual ~QFontEngine();

    
    
    struct Properties {
        QByteArray postscriptName;
        QByteArray copyright;
        QRectF boundingBox;
        QFixed emSquare;
        QFixed ascent;
        QFixed descent;
        QFixed leading;
        QFixed italicAngle;
        QFixed capHeight;
        QFixed lineWidth;
    };
    virtual Properties properties() const;
    virtual void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics);
    virtual QByteArray getSfntTable(uint  ) const { return QByteArray(); }

    struct FaceId {



        FaceId() : index(0), encoding(0) {}
        QByteArray filename;
        int index;
        int encoding;
    };
    virtual FaceId faceId() const { return FaceId(); }
    enum SynthesizedFlags {
        SynthesizedItalic = 0x1,
        SynthesizedBold = 0x2,
        SynthesizedStretch = 0x4
    };
    virtual int synthesized() const { return 0; }

     
    virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const = 0;

    virtual QOpenType *openType() const { return 0; }
    virtual void recalcAdvances(int , QGlyphLayout *, QTextEngine::ShaperFlags) const {}
    virtual void doKerning(int , QGlyphLayout *, QTextEngine::ShaperFlags) const {}




    virtual void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nglyphs,
                                 QPainterPath *path, QTextItem::RenderFlags flags);
    void getGlyphPositions(const QGlyphLayout *glyphs, int nglyphs, const QMatrix &matrix, QTextItem::RenderFlags flags,
                           QVarLengthArray<glyph_t> &glyphs_out, QVarLengthArray<QFixedPoint> &positions);

    virtual void addOutlineToPath(qreal, qreal, const QGlyphLayout *, int, QPainterPath *, QTextItem::RenderFlags flags);
    void addBitmapFontToPath(qreal x, qreal y, const QGlyphLayout *, int, QPainterPath *, QTextItem::RenderFlags);

    virtual glyph_metrics_t boundingBox(const QGlyphLayout *glyphs, int numGlyphs) = 0;
    virtual glyph_metrics_t boundingBox(glyph_t glyph) = 0;

    virtual QFixed ascent() const = 0;
    virtual QFixed descent() const = 0;
    virtual QFixed leading() const = 0;
    virtual QFixed xHeight() const;

    virtual QFixed lineThickness() const;
    virtual QFixed underlinePosition() const;

    virtual qreal maxCharWidth() const = 0;
    virtual qreal minLeftBearing() const { return qreal(); }
    virtual qreal minRightBearing() const { return qreal(); }

    virtual const char *name() const = 0;

    virtual bool canRender(const QChar *string, int len) = 0;

    virtual Type type() const = 0;

    QAtomic     ref;
    QFontDef fontDef;
    uint cache_cost; 
    int cache_count;
    uint fsType;

#line 198 "text/qfontengine_p.h"
};

inline bool operator ==(const QFontEngine::FaceId &f1, const QFontEngine::FaceId &f2)
{
    return (f1.index == f2.index) && (f1.encoding == f2.encoding) && (f1.filename == f2.filename);
}

inline uint qHash(const QFontEngine::FaceId &f)
{
    return qHash((f.index << 16) + f.encoding) + qHash(f.filename);
}


class QGlyph;

#line 316 "text/qfontengine_p.h"


class QFontEngineBox : public QFontEngine
{
public:
    QFontEngineBox(int size);
    ~QFontEngineBox();

    bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const;




    void addOutlineToPath(qreal x, qreal y, const QGlyphLayout *glyphs, int numGlyphs, QPainterPath *path, QTextItem::RenderFlags flags);

    glyph_metrics_t boundingBox(const QGlyphLayout *glyphs, int numGlyphs);
    glyph_metrics_t boundingBox(glyph_t glyph);

    QFixed ascent() const;
    QFixed descent() const;
    QFixed leading() const;
    qreal maxCharWidth() const;
    qreal minLeftBearing() const { return 0; }
    qreal minRightBearing() const { return 0; }


    int cmap() const;

    const char *name() const;

    bool canRender(const QChar *string, int len);

    Type type() const;
    inline int size() const { return _size; }

private:
    friend class QFontPrivate;
    int _size;
};

class  QFontEngineMulti : public QFontEngine
{
public:
    explicit QFontEngineMulti(int engineCount);
    ~QFontEngineMulti();

    bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs,
                      QTextEngine::ShaperFlags flags) const;

    glyph_metrics_t boundingBox(const QGlyphLayout *glyphs, int numGlyphs);
    glyph_metrics_t boundingBox(glyph_t glyph);

    void recalcAdvances(int , QGlyphLayout *, QTextEngine::ShaperFlags) const;
    void doKerning(int , QGlyphLayout *, QTextEngine::ShaperFlags) const;
    void addOutlineToPath(qreal, qreal, const QGlyphLayout *, int, QPainterPath *, QTextItem::RenderFlags flags);

    QFixed ascent() const;
    QFixed descent() const;
    QFixed leading() const;
    QFixed xHeight() const;

    QFixed lineThickness() const;
    QFixed underlinePosition() const;
    qreal maxCharWidth() const;
    qreal minLeftBearing() const;
    qreal minRightBearing() const;

    inline Type type() const
    { return QFontEngine::Multi; }

    bool canRender(const QChar *string, int len);
    inline const char *name() const
    { return "Multi"; }

    QFontEngine *engine(int at) const;

protected:
    friend class QPSPrintEnginePrivate;
    friend class QPSPrintEngineFontMulti;
    virtual void loadEngine(int at) = 0;
    QVector<QFontEngine *> engines;
};

#line 493 "text/qfontengine_p.h"

#line 1 "../../include/QtGui/private/qfontengine_x11_p.h"
#line 1 "../../include/QtGui/private/../../../src/gui/text/qfontengine_x11_p.h"



















 














#line 1 "../../include/QtGui/private/qt_x11_p.h"
#line 1 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"



















 















#line 1 "../../include/QtGui/qwindowdefs.h"
#line 37 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"
#line 1 "../../include/QtCore/qlist.h"
#line 38 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"




#line 1 "/usr/include/X11/Xlib.h"
 
 
























 
 






 





#line 55 "/usr/include/X11/Xlib.h"





#line 1 "/usr/include/X11/X.h"


 

 

















































 
 




 





 



typedef unsigned long XID;



typedef unsigned long Mask;



typedef unsigned long Atom;		 

typedef unsigned long VisualID;
typedef unsigned long Time;
#line 100 "/usr/include/X11/X.h"

typedef XID Window;
typedef XID Drawable;


typedef XID Font;

typedef XID Pixmap;
typedef XID Cursor;
typedef XID Colormap;
typedef XID GContext;
typedef XID KeySym;

typedef unsigned char KeyCode;



 
































 


 

#line 181 "/usr/include/X11/X.h"



 

#line 220 "/usr/include/X11/X.h"



 

#line 233 "/usr/include/X11/X.h"



 
#line 245 "/usr/include/X11/X.h"



 












 







 







		       
 

#line 288 "/usr/include/X11/X.h"

 





 




 






 


 




 




 




 







 

#line 343 "/usr/include/X11/X.h"

 







 

#line 380 "/usr/include/X11/X.h"






 

 
 




 

#line 411 "/usr/include/X11/X.h"

 

#line 421 "/usr/include/X11/X.h"


 

#line 436 "/usr/include/X11/X.h"

 



 





 





 




 





 







 




 







 

 

#line 505 "/usr/include/X11/X.h"

 





 






 





 






 




 




 






 




 





 





 

#line 591 "/usr/include/X11/X.h"




 

 








 

 







 

 





 







 

 







 








 

#line 661 "/usr/include/X11/X.h"











 












 






 

 




 






 

#line 714 "/usr/include/X11/X.h"


 




#line 61 "/usr/include/X11/Xlib.h"

 
#line 1 "/usr/include/X11/Xfuncproto.h"
 
























 
 

 






















#line 59 "/usr/include/X11/Xfuncproto.h"



#line 71 "/usr/include/X11/Xfuncproto.h"

#line 79 "/usr/include/X11/Xfuncproto.h"

#line 93 "/usr/include/X11/Xfuncproto.h"







#line 64 "/usr/include/X11/Xlib.h"
#line 1 "/usr/include/X11/Xosdefs.h"



























 
 











 

















#line 65 "/usr/include/X11/Xosdefs.h"










  
#line 82 "/usr/include/X11/Xosdefs.h"







#line 100 "/usr/include/X11/Xosdefs.h"







#line 119 "/usr/include/X11/Xosdefs.h"





















#line 148 "/usr/include/X11/Xosdefs.h"

#line 157 "/usr/include/X11/Xosdefs.h"

#line 164 "/usr/include/X11/Xosdefs.h"



#line 65 "/usr/include/X11/Xlib.h"

#line 73 "/usr/include/X11/Xlib.h"

#line 84 "/usr/include/X11/Xlib.h"

#line 92 "/usr/include/X11/Xlib.h"

extern int
_Xmblen(




    char *str,
    int len

    );


 


typedef char *XPointer;










#line 153 "/usr/include/X11/Xlib.h"

 
#line 176 "/usr/include/X11/Xlib.h"



 
typedef struct _XExtData {
	int number;		 
	struct _XExtData *next;	 
	int (*free_private)(	 
	struct _XExtData *extension
	);
	XPointer private_data;	 
} XExtData;



 
typedef struct {		 
	int extension;		 
	int major_opcode;	 
	int first_event;	 
	int first_error;	 
} XExtCodes;



 

typedef struct {
    int depth;
    int bits_per_pixel;
    int scanline_pad;
} XPixmapFormatValues;




 
typedef struct {
	int function;		 
	unsigned long plane_mask; 
	unsigned long foreground; 
	unsigned long background; 
	int line_width;		 
	int line_style;	 	 
	int cap_style;	  	
 
	int join_style;	 	 
	int fill_style;	 	
 
	int fill_rule;	  	 
	int arc_mode;		 
	Pixmap tile;		 
	Pixmap stipple;		 
	int ts_x_origin;	 
	int ts_y_origin;
        Font font;	         
	int subwindow_mode;      
	int graphics_exposures; 
	int clip_x_origin;	 
	int clip_y_origin;
	Pixmap clip_mask;	 
	int dash_offset;	 
	char dashes;
} XGCValues;




 

typedef struct _XGC
#line 254 "/usr/include/X11/Xlib.h"
*GC;



 
typedef struct {
	XExtData *ext_data;	 
	VisualID visualid;	 

	int c_class;		 



	unsigned long red_mask, green_mask, blue_mask;	 
	int bits_per_rgb;	 
	int map_entries;	 
} Visual;



 	
typedef struct {
	int depth;		 
	int nvisuals;		 
	Visual *visuals;	 
} Depth;





 

struct _XDisplay;		 

typedef struct {
	XExtData *ext_data;	 
	struct _XDisplay *display; 
	Window root;		 
	int width, height;	 
	int mwidth, mheight;	 
	int ndepths;		 
	Depth *depths;		 
	int root_depth;		 
	Visual *root_visual;	 
	GC default_gc;		 
	Colormap cmap;		 
	unsigned long white_pixel;
	unsigned long black_pixel;	 
	int max_maps, min_maps;	 
	int backing_store;	 
	int save_unders;	
	long root_input_mask;	 
} Screen;



 
typedef struct {
	XExtData *ext_data;	 
	int depth;		 
	int bits_per_pixel;	 
	int scanline_pad;	 
} ScreenFormat;



 
typedef struct {
    Pixmap background_pixmap;	 
    unsigned long background_pixel;	 
    Pixmap border_pixmap;	 
    unsigned long border_pixel;	 
    int bit_gravity;		 
    int win_gravity;		 
    int backing_store;		 
    unsigned long backing_planes; 
    unsigned long backing_pixel; 
    int save_under;		 
    long event_mask;		 
    long do_not_propagate_mask;	 
    int override_redirect;	 
    Colormap colormap;		 
    Cursor cursor;		 
} XSetWindowAttributes;

typedef struct {
    int x, y;			 
    int width, height;		 
    int border_width;		 
    int depth;          	 
    Visual *visual;		 
    Window root;        	 

    int c_class;		 



    int bit_gravity;		 
    int win_gravity;		 
    int backing_store;		 
    unsigned long backing_planes; 
    unsigned long backing_pixel; 
    int save_under;		 
    Colormap colormap;		 
    int map_installed;		 
    int map_state;		 
    long all_event_masks;	 
    long your_event_mask;	 
    long do_not_propagate_mask;  
    int override_redirect;	 
    Screen *screen;		 
} XWindowAttributes;




 

typedef struct {
	int family;		 
	int length;		 
	char *address;		 
} XHostAddress;



 
typedef struct {
	int typelength;		 
	int valuelength;	 
	char *type;		 
	char *value;		 
} XServerInterpretedAddress;



 
typedef struct _XImage {
    int width, height;		 
    int xoffset;		 
    int format;			 
    char *data;			 
    int byte_order;		 
    int bitmap_unit;		 
    int bitmap_bit_order;	 
    int bitmap_pad;		 
    int depth;			 
    int bytes_per_line;		 
    int bits_per_pixel;		 
    unsigned long red_mask;	 
    unsigned long green_mask;
    unsigned long blue_mask;
    XPointer obdata;		 
    struct funcs {		 
	struct _XImage *(*create_image)(
		struct _XDisplay*  ,
		Visual*		 ,
		unsigned int	 ,
		int		 ,
		int		 ,
		char*		 ,
		unsigned int	 ,
		unsigned int	 ,
		int		 ,
		int		 );
	int (*destroy_image)        (struct _XImage *);
	unsigned long (*get_pixel)  (struct _XImage *, int, int);
	int (*put_pixel)            (struct _XImage *, int, int, unsigned long);
	struct _XImage *(*sub_image)(struct _XImage *, int, int, unsigned int, unsigned int);
	int (*add_pixel)            (struct _XImage *, long);
	} f;
} XImage;



 
typedef struct {
    int x, y;
    int width, height;
    int border_width;
    Window sibling;
    int stack_mode;
} XWindowChanges;



 
typedef struct {
	unsigned long pixel;
	unsigned short red, green, blue;
	char flags;   
	char pad;
} XColor;





 
typedef struct {
    short x1, y1, x2, y2;
} XSegment;

typedef struct {
    short x, y;
} XPoint;
    
typedef struct {
    short x, y;
    unsigned short width, height;
} XRectangle;
    
typedef struct {
    short x, y;
    unsigned short width, height;
    short angle1, angle2;
} XArc;


 

typedef struct {
        int key_click_percent;
        int bell_percent;
        int bell_pitch;
        int bell_duration;
        int led;
        int led_mode;
        int key;
        int auto_repeat_mode;    
} XKeyboardControl;

 

typedef struct {
        int key_click_percent;
	int bell_percent;
	unsigned int bell_pitch, bell_duration;
	unsigned long led_mask;
	int global_auto_repeat;
	char auto_repeats[32];
} XKeyboardState;

 

typedef struct {
        Time time;
	short x, y;
} XTimeCoord;

 

typedef struct {
 	int max_keypermod;	 
 	KeyCode *modifiermap;	 
} XModifierKeymap;






 

typedef struct _XDisplay Display;


struct _XPrivate;		 
struct _XrmHashBucketRec;

typedef struct 



{
	XExtData *ext_data;	 
	struct _XPrivate *private1;
	int fd;			 
	int private2;
	int proto_major_version; 
	int proto_minor_version; 
	char *vendor;		 
        XID private3;
	XID private4;
	XID private5;
	int private6;
	XID (*resource_alloc)(	 
		struct _XDisplay*
	);
	int byte_order;		 
	int bitmap_unit;	 
	int bitmap_pad;		 
	int bitmap_bit_order;	 
	int nformats;		 
	ScreenFormat *pixmap_format;	 
	int private8;
	int release;		 
	struct _XPrivate *private9, *private10;
	int qlen;		 
	unsigned long last_request_read;  
	unsigned long request;	 
	XPointer private11;
	XPointer private12;
	XPointer private13;
	XPointer private14;
	unsigned max_request_size;  
	struct _XrmHashBucketRec *db;
	int (*private15)(
		struct _XDisplay*
		);
	char *display_name;	 
	int default_screen;	 
	int nscreens;		 
	Screen *screens;	 
	unsigned long motion_buffer;	 
	unsigned long private16;
	int min_keycode;	 
	int max_keycode;	 
	XPointer private17;
	XPointer private18;
	int private19;
	char *xdefaults;	 
	 
}



*_XPrivDisplay;





 
typedef struct {
	int type;		 
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;	         
	Window root;	         
	Window subwindow;	 
	Time time;		 
	int x, y;		 
	int x_root, y_root;	 
	unsigned int state;	 
	unsigned int keycode;	 
	int same_screen;	 
} XKeyEvent;
typedef XKeyEvent XKeyPressedEvent;
typedef XKeyEvent XKeyReleasedEvent;

typedef struct {
	int type;		 
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;	         
	Window root;	         
	Window subwindow;	 
	Time time;		 
	int x, y;		 
	int x_root, y_root;	 
	unsigned int state;	 
	unsigned int button;	 
	int same_screen;	 
} XButtonEvent;
typedef XButtonEvent XButtonPressedEvent;
typedef XButtonEvent XButtonReleasedEvent;

typedef struct {
	int type;		 
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;	         
	Window root;	         
	Window subwindow;	 
	Time time;		 
	int x, y;		 
	int x_root, y_root;	 
	unsigned int state;	 
	char is_hint;		 
	int same_screen;	 
} XMotionEvent;
typedef XMotionEvent XPointerMovedEvent;

typedef struct {
	int type;		 
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;	         
	Window root;	         
	Window subwindow;	 
	Time time;		 
	int x, y;		 
	int x_root, y_root;	 
	int mode;		 
	int detail;
	


 
	int same_screen;	 
	int focus;		 
	unsigned int state;	 
} XCrossingEvent;
typedef XCrossingEvent XEnterWindowEvent;
typedef XCrossingEvent XLeaveWindowEvent;

typedef struct {
	int type;		 
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;		 
	int mode;		
 
	int detail;
	



 
} XFocusChangeEvent;
typedef XFocusChangeEvent XFocusInEvent;
typedef XFocusChangeEvent XFocusOutEvent;

 
typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;
	char key_vector[32];
} XKeymapEvent;	

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;
	int x, y;
	int width, height;
	int count;		 
} XExposeEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Drawable drawable;
	int x, y;
	int width, height;
	int count;		 
	int major_code;		 
	int minor_code;		 
} XGraphicsExposeEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Drawable drawable;
	int major_code;		 
	int minor_code;		 
} XNoExposeEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;
	int state;		 
} XVisibilityEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window parent;		 
	Window window;		 
	int x, y;		 
	int width, height;	 
	int border_width;	 
	int override_redirect;	 
} XCreateWindowEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window event;
	Window window;
} XDestroyWindowEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window event;
	Window window;
	int from_configure;
} XUnmapEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window event;
	Window window;
	int override_redirect;	 
} XMapEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window parent;
	Window window;
} XMapRequestEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window event;
	Window window;
	Window parent;
	int x, y;
	int override_redirect;
} XReparentEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window event;
	Window window;
	int x, y;
	int width, height;
	int border_width;
	Window above;
	int override_redirect;
} XConfigureEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window event;
	Window window;
	int x, y;
} XGravityEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;
	int width, height;
} XResizeRequestEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window parent;
	Window window;
	int x, y;
	int width, height;
	int border_width;
	Window above;
	int detail;		 
	unsigned long value_mask;
} XConfigureRequestEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window event;
	Window window;
	int place;		 
} XCirculateEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window parent;
	Window window;
	int place;		 
} XCirculateRequestEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;
	Atom atom;
	Time time;
	int state;		 
} XPropertyEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;
	Atom selection;
	Time time;
} XSelectionClearEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window owner;
	Window requestor;
	Atom selection;
	Atom target;
	Atom property;
	Time time;
} XSelectionRequestEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window requestor;
	Atom selection;
	Atom target;
	Atom property;		 
	Time time;
} XSelectionEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;
	Colormap colormap;	 

	int c_new;		 



	int state;		 
} XColormapEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;
	Atom message_type;
	int format;
	union {
		char b[20];
		short s[10];
		long l[5];
		} data;
} XClientMessageEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display;	 
	Window window;		 
	int request;		
 
	int first_keycode;	 
	int count;		 
} XMappingEvent;

typedef struct {
	int type;
	Display *display;	 
	XID resourceid;		 
	unsigned long serial;	 
	unsigned char error_code;	 
	unsigned char request_code;	 
	unsigned char minor_code;	 
} XErrorEvent;

typedef struct {
	int type;
	unsigned long serial;	 
	int send_event;	 
	Display *display; 
	Window window;	 
} XAnyEvent;




 
typedef union _XEvent {
        int type;		 
	XAnyEvent xany;
	XKeyEvent xkey;
	XButtonEvent xbutton;
	XMotionEvent xmotion;
	XCrossingEvent xcrossing;
	XFocusChangeEvent xfocus;
	XExposeEvent xexpose;
	XGraphicsExposeEvent xgraphicsexpose;
	XNoExposeEvent xnoexpose;
	XVisibilityEvent xvisibility;
	XCreateWindowEvent xcreatewindow;
	XDestroyWindowEvent xdestroywindow;
	XUnmapEvent xunmap;
	XMapEvent xmap;
	XMapRequestEvent xmaprequest;
	XReparentEvent xreparent;
	XConfigureEvent xconfigure;
	XGravityEvent xgravity;
	XResizeRequestEvent xresizerequest;
	XConfigureRequestEvent xconfigurerequest;
	XCirculateEvent xcirculate;
	XCirculateRequestEvent xcirculaterequest;
	XPropertyEvent xproperty;
	XSelectionClearEvent xselectionclear;
	XSelectionRequestEvent xselectionrequest;
	XSelectionEvent xselection;
	XColormapEvent xcolormap;
	XClientMessageEvent xclient;
	XMappingEvent xmapping;
	XErrorEvent xerror;
	XKeymapEvent xkeymap;
	long pad[24];
} XEvent;






 
typedef struct {
    short	lbearing;	 
    short	rbearing;	 
    short	width;		 
    short	ascent;		 
    short	descent;	 
    unsigned short attributes;	 
} XCharStruct;




 
typedef struct {
    Atom name;
    unsigned long card32;
} XFontProp;

typedef struct {
    XExtData	*ext_data;	 
    Font        fid;             
    unsigned	direction;	 
    unsigned	min_char_or_byte2; 
    unsigned	max_char_or_byte2; 
    unsigned	min_byte1;	 
    unsigned	max_byte1;	 
    int	all_chars_exist; 
    unsigned	default_char;	 
    int         n_properties;    
    XFontProp	*properties;	 
    XCharStruct	min_bounds;	 
    XCharStruct	max_bounds;	 
    XCharStruct	*per_char;	 
    int		ascent;		 
    int		descent;	 
} XFontStruct;



 
typedef struct {
    char *chars;		 
    int nchars;			 
    int delta;			 
    Font font;			 
} XTextItem;

typedef struct {		 
    unsigned char byte1;
    unsigned char byte2;
} XChar2b;

typedef struct {
    XChar2b *chars;		 
    int nchars;			 
    int delta;			 
    Font font;			 
} XTextItem16;


typedef union { Display *display;
		GC gc;
		Visual *visual;
		Screen *screen;
		ScreenFormat *pixmap_format;
		XFontStruct *font; } XEDataObject;

typedef struct {
    XRectangle      max_ink_extent;
    XRectangle      max_logical_extent;
} XFontSetExtents;



 

typedef struct _XOM *XOM;
typedef struct _XOC *XOC, *XFontSet;

typedef struct {
    char           *chars;
    int             nchars;
    int             delta;
    XFontSet        font_set;
} XmbTextItem;

typedef struct {
    wchar_t        *chars;
    int             nchars;
    int             delta;
    XFontSet        font_set;
} XwcTextItem;

#line 1123 "/usr/include/X11/Xlib.h"

typedef struct {
    int charset_count;
    char **charset_list;
} XOMCharSetList;

typedef enum {
    XOMOrientation_LTR_TTB,
    XOMOrientation_RTL_TTB,
    XOMOrientation_TTB_LTR,
    XOMOrientation_TTB_RTL,
    XOMOrientation_Context
} XOrientation;

typedef struct {
    int num_orientation;
    XOrientation *orientation;	 
} XOMOrientation;

typedef struct {
    int num_font;
    XFontStruct **font_struct_list;
    char **font_name_list;
} XOMFontInfo;

typedef struct _XIM *XIM;
typedef struct _XIC *XIC;

typedef void (*XIMProc)(
    XIM,
    XPointer,
    XPointer
);

typedef int (*XICProc)(
    XIC,
    XPointer,
    XPointer
);

typedef void (*XIDProc)(
    Display*,
    XPointer,
    XPointer
);

typedef unsigned long XIMStyle;

typedef struct {
    unsigned short count_styles;
    XIMStyle *supported_styles;
} XIMStyles;

#line 1185 "/usr/include/X11/Xlib.h"

#line 1217 "/usr/include/X11/Xlib.h"

#line 1229 "/usr/include/X11/Xlib.h"







typedef void *XVaNestedList;

typedef struct {
    XPointer client_data;
    XIMProc callback;
} XIMCallback;

typedef struct {
    XPointer client_data;
    XICProc callback;
} XICCallback;

typedef unsigned long XIMFeedback;

#line 1259 "/usr/include/X11/Xlib.h"

typedef struct _XIMText {
    unsigned short length;
    XIMFeedback *feedback;
    int encoding_is_wchar; 
    union {
	char *multi_byte;
	wchar_t *wide_char;
    } string; 
} XIMText;

typedef	unsigned long	 XIMPreeditState;





typedef	struct	_XIMPreeditStateNotifyCallbackStruct {
    XIMPreeditState state;
} XIMPreeditStateNotifyCallbackStruct;

typedef	unsigned long	 XIMResetState;




typedef unsigned long XIMStringConversionFeedback;

#line 1293 "/usr/include/X11/Xlib.h"

typedef struct _XIMStringConversionText {
    unsigned short length;
    XIMStringConversionFeedback *feedback;
    int encoding_is_wchar; 
    union {
	char *mbs;
	wchar_t *wcs;
    } string; 
} XIMStringConversionText;

typedef	unsigned short	XIMStringConversionPosition;

typedef	unsigned short	XIMStringConversionType;






typedef	unsigned short	XIMStringConversionOperation;




typedef enum {
    XIMForwardChar, XIMBackwardChar,
    XIMForwardWord, XIMBackwardWord,
    XIMCaretUp, XIMCaretDown,
    XIMNextLine, XIMPreviousLine,
    XIMLineStart, XIMLineEnd, 
    XIMAbsolutePosition,
    XIMDontChange
} XIMCaretDirection;

typedef struct _XIMStringConversionCallbackStruct {
    XIMStringConversionPosition position;
    XIMCaretDirection direction;
    XIMStringConversionOperation operation;
    unsigned short factor;
    XIMStringConversionText *text;
} XIMStringConversionCallbackStruct;

typedef struct _XIMPreeditDrawCallbackStruct {
    int caret;		 
    int chg_first;	 
    int chg_length;	 
    XIMText *text;
} XIMPreeditDrawCallbackStruct;

typedef enum {
    XIMIsInvisible,	  
    XIMIsPrimary,	 
    XIMIsSecondary	 
} XIMCaretStyle;

typedef struct _XIMPreeditCaretCallbackStruct {
    int position;		  
    XIMCaretDirection direction;  
    XIMCaretStyle style;	  
} XIMPreeditCaretCallbackStruct;

typedef enum {
    XIMTextType,
    XIMBitmapType
} XIMStatusDataType;
	
typedef struct _XIMStatusDrawCallbackStruct {
    XIMStatusDataType type;
    union {
	XIMText *text;
	Pixmap  bitmap;
    } data;
} XIMStatusDrawCallbackStruct;

typedef struct _XIMHotKeyTrigger {
    KeySym	 keysym;
    int		 modifier;
    int		 modifier_mask;
} XIMHotKeyTrigger;

typedef struct _XIMHotKeyTriggers {
    int			 num_hot_key;
    XIMHotKeyTrigger	*key;
} XIMHotKeyTriggers;

typedef	unsigned long	 XIMHotKeyState;




typedef struct {
    unsigned short count_values;
    char **supported_values;
} XIMValuesList;

extern "C" {





extern int _Xdebug;

extern XFontStruct *XLoadQueryFont(
    Display*		 ,
    const char*	 
);

extern XFontStruct *XQueryFont(
    Display*		 ,
    XID			 
);


extern XTimeCoord *XGetMotionEvents(
    Display*		 ,
    Window		 ,
    Time		 ,
    Time		 ,
    int*		 
);

extern XModifierKeymap *XDeleteModifiermapEntry(
    XModifierKeymap*	 ,

    unsigned int	 ,



    int			 
);

extern XModifierKeymap	*XGetModifierMapping(
    Display*		 
);

extern XModifierKeymap	*XInsertModifiermapEntry(
    XModifierKeymap*	 ,

    unsigned int	 ,



    int			     
);

extern XModifierKeymap *XNewModifiermap(
    int			 
);

extern XImage *XCreateImage(
    Display*		 ,
    Visual*		 ,
    unsigned int	 ,
    int			 ,
    int			 ,
    char*		 ,
    unsigned int	 ,
    unsigned int	 ,
    int			 ,
    int			 
);
extern int XInitImage(
    XImage*		 
);
extern XImage *XGetImage(
    Display*		 ,
    Drawable		 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned long	 ,
    int			 
);
extern XImage *XGetSubImage(
    Display*		 ,
    Drawable		 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned long	 ,
    int			 ,
    XImage*		 ,
    int			 ,
    int			 
);



 
extern Display *XOpenDisplay(
    const char*	 
);

extern void XrmInitialize(
    void
);

extern char *XFetchBytes(
    Display*		 ,
    int*		 
);
extern char *XFetchBuffer(
    Display*		 ,
    int*		 ,
    int			 
);
extern char *XGetAtomName(
    Display*		 ,
    Atom		 
);
extern int XGetAtomNames(
    Display*		 ,
    Atom*		 ,
    int			 ,
    char**		 
);
extern char *XGetDefault(
    Display*		 ,
    const char*	 ,
    const char*	 		  
);
extern char *XDisplayName(
    const char*	 
);
extern char *XKeysymToString(
    KeySym		 
);

extern int (*XSynchronize(
    Display*		 ,
    int		 
))(
    Display*		 
);
extern int (*XSetAfterFunction(
    Display*		 ,
    int (*) (
	     Display*	 
            )		 
))(
    Display*		 
);
extern Atom XInternAtom(
    Display*		 ,
    const char*	 ,
    int		 		 
);
extern int XInternAtoms(
    Display*		 ,
    char**		 ,
    int			 ,
    int		 ,
    Atom*		 
);
extern Colormap XCopyColormapAndFree(
    Display*		 ,
    Colormap		 
);
extern Colormap XCreateColormap(
    Display*		 ,
    Window		 ,
    Visual*		 ,
    int			 			 
);
extern Cursor XCreatePixmapCursor(
    Display*		 ,
    Pixmap		 ,
    Pixmap		 ,
    XColor*		 ,
    XColor*		 ,
    unsigned int	 ,
    unsigned int	 			   
);
extern Cursor XCreateGlyphCursor(
    Display*		 ,
    Font		 ,
    Font		 ,
    unsigned int	 ,
    unsigned int	 ,
    XColor const *	 ,
    XColor const *	 
);
extern Cursor XCreateFontCursor(
    Display*		 ,
    unsigned int	 
);
extern Font XLoadFont(
    Display*		 ,
    const char*	 
);
extern GC XCreateGC(
    Display*		 ,
    Drawable		 ,
    unsigned long	 ,
    XGCValues*		 
);
extern GContext XGContextFromGC(
    GC			 
);
extern void XFlushGC(
    Display*		 ,
    GC			 
);
extern Pixmap XCreatePixmap(
    Display*		 ,
    Drawable		 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned int	 		        
);
extern Pixmap XCreateBitmapFromData(
    Display*		 ,
    Drawable		 ,
    const char*	 ,
    unsigned int	 ,
    unsigned int	 
);
extern Pixmap XCreatePixmapFromBitmapData(
    Display*		 ,
    Drawable		 ,
    char*		 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned long	 ,
    unsigned long	 ,
    unsigned int	 
);
extern Window XCreateSimpleWindow(
    Display*		 ,
    Window		 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned long	 ,
    unsigned long	 
);
extern Window XGetSelectionOwner(
    Display*		 ,
    Atom		 
);
extern Window XCreateWindow(
    Display*		 ,
    Window		 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned int	 ,
    int			 ,
    unsigned int	 ,
    Visual*		 ,
    unsigned long	 ,
    XSetWindowAttributes*	 
); 
extern Colormap *XListInstalledColormaps(
    Display*		 ,
    Window		 ,
    int*		 
);
extern char **XListFonts(
    Display*		 ,
    const char*	 ,
    int			 ,
    int*		 
);
extern char **XListFontsWithInfo(
    Display*		 ,
    const char*	 ,
    int			 ,
    int*		 ,
    XFontStruct**	 
);
extern char **XGetFontPath(
    Display*		 ,
    int*		 
);
extern char **XListExtensions(
    Display*		 ,
    int*		 
);
extern Atom *XListProperties(
    Display*		 ,
    Window		 ,
    int*		 
);
extern XHostAddress *XListHosts(
    Display*		 ,
    int*		 ,
    int*		 
);
extern KeySym XKeycodeToKeysym(
    Display*		 ,

    unsigned int	 ,



    int			 
);
extern KeySym XLookupKeysym(
    XKeyEvent*		 ,
    int			 
);
extern KeySym *XGetKeyboardMapping(
    Display*		 ,

    unsigned int	 ,



    int			 ,
    int*		 
);
extern KeySym XStringToKeysym(
    const char*	 
);
extern long XMaxRequestSize(
    Display*		 
);
extern long XExtendedMaxRequestSize(
    Display*		 
);
extern char *XResourceManagerString(
    Display*		 
);
extern char *XScreenResourceString(
	Screen*		 
);
extern unsigned long XDisplayMotionBufferSize(
    Display*		 
);
extern VisualID XVisualIDFromVisual(
    Visual*		 
);

 

extern int XInitThreads(
    void
);

extern void XLockDisplay(
    Display*		 
);

extern void XUnlockDisplay(
    Display*		 
);

 

extern XExtCodes *XInitExtension(
    Display*		 ,
    const char*	 
);

extern XExtCodes *XAddExtension(
    Display*		 
);
extern XExtData *XFindOnExtensionList(
    XExtData**		 ,
    int			 
);
extern XExtData **XEHeadOfExtensionList(
    XEDataObject	 
);

 
extern Window XRootWindow(
    Display*		 ,
    int			 
);
extern Window XDefaultRootWindow(
    Display*		 
);
extern Window XRootWindowOfScreen(
    Screen*		 
);
extern Visual *XDefaultVisual(
    Display*		 ,
    int			 
);
extern Visual *XDefaultVisualOfScreen(
    Screen*		 
);
extern GC XDefaultGC(
    Display*		 ,
    int			 
);
extern GC XDefaultGCOfScreen(
    Screen*		 
);
extern unsigned long XBlackPixel(
    Display*		 ,
    int			 
);
extern unsigned long XWhitePixel(
    Display*		 ,
    int			 
);
extern unsigned long XAllPlanes(
    void
);
extern unsigned long XBlackPixelOfScreen(
    Screen*		 
);
extern unsigned long XWhitePixelOfScreen(
    Screen*		 
);
extern unsigned long XNextRequest(
    Display*		 
);
extern unsigned long XLastKnownRequestProcessed(
    Display*		 
);
extern char *XServerVendor(
    Display*		 
);
extern char *XDisplayString(
    Display*		 
);
extern Colormap XDefaultColormap(
    Display*		 ,
    int			 
);
extern Colormap XDefaultColormapOfScreen(
    Screen*		 
);
extern Display *XDisplayOfScreen(
    Screen*		 
);
extern Screen *XScreenOfDisplay(
    Display*		 ,
    int			 
);
extern Screen *XDefaultScreenOfDisplay(
    Display*		 
);
extern long XEventMaskOfScreen(
    Screen*		 
);

extern int XScreenNumberOfScreen(
    Screen*		 
);

typedef int (*XErrorHandler) (	     
    Display*		 ,
    XErrorEvent*	 
);

extern XErrorHandler XSetErrorHandler (
    XErrorHandler	 
);


typedef int (*XIOErrorHandler) (     
    Display*		 
);

extern XIOErrorHandler XSetIOErrorHandler (
    XIOErrorHandler	 
);


extern XPixmapFormatValues *XListPixmapFormats(
    Display*		 ,
    int*		 
);
extern int *XListDepths(
    Display*		 ,
    int			 ,
    int*		 
);

 
 
extern int XReconfigureWMWindow(
    Display*		 ,
    Window		 ,
    int			 ,
    unsigned int	 ,
    XWindowChanges*	 
);

extern int XGetWMProtocols(
    Display*		 ,
    Window		 ,
    Atom**		 ,
    int*		 
);
extern int XSetWMProtocols(
    Display*		 ,
    Window		 ,
    Atom*		 ,
    int			 
);
extern int XIconifyWindow(
    Display*		 ,
    Window		 ,
    int			 
);
extern int XWithdrawWindow(
    Display*		 ,
    Window		 ,
    int			 
);
extern int XGetCommand(
    Display*		 ,
    Window		 ,
    char***		 ,
    int*		 
);
extern int XGetWMColormapWindows(
    Display*		 ,
    Window		 ,
    Window**		 ,
    int*		 
);
extern int XSetWMColormapWindows(
    Display*		 ,
    Window		 ,
    Window*		 ,
    int			 
);
extern void XFreeStringList(
    char**		 
);
extern int XSetTransientForHint(
    Display*		 ,
    Window		 ,
    Window		 
);

 

extern int XActivateScreenSaver(
    Display*		 
);

extern int XAddHost(
    Display*		 ,
    XHostAddress*	 
);

extern int XAddHosts(
    Display*		 ,
    XHostAddress*	 ,
    int			     
);

extern int XAddToExtensionList(
    struct _XExtData**	 ,
    XExtData*		 
);

extern int XAddToSaveSet(
    Display*		 ,
    Window		 
);

extern int XAllocColor(
    Display*		 ,
    Colormap		 ,
    XColor*		 
);

extern int XAllocColorCells(
    Display*		 ,
    Colormap		 ,
    int	         ,
    unsigned long*	 ,
    unsigned int	 ,
    unsigned long*	 ,
    unsigned int 	 
);

extern int XAllocColorPlanes(
    Display*		 ,
    Colormap		 ,
    int		 ,
    unsigned long*	 ,
    int			 ,
    int			 ,
    int			 ,
    int			 ,
    unsigned long*	 ,
    unsigned long*	 ,
    unsigned long*	 
);

extern int XAllocNamedColor(
    Display*		 ,
    Colormap		 ,
    const char*	 ,
    XColor*		 ,
    XColor*		 
);

extern int XAllowEvents(
    Display*		 ,
    int			 ,
    Time		 
);

extern int XAutoRepeatOff(
    Display*		 
);

extern int XAutoRepeatOn(
    Display*		 
);

extern int XBell(
    Display*		 ,
    int			 
);

extern int XBitmapBitOrder(
    Display*		 
);

extern int XBitmapPad(
    Display*		 
);

extern int XBitmapUnit(
    Display*		 
);

extern int XCellsOfScreen(
    Screen*		 
);

extern int XChangeActivePointerGrab(
    Display*		 ,
    unsigned int	 ,
    Cursor		 ,
    Time		 
);

extern int XChangeGC(
    Display*		 ,
    GC			 ,
    unsigned long	 ,
    XGCValues*		 
);

extern int XChangeKeyboardControl(
    Display*		 ,
    unsigned long	 ,
    XKeyboardControl*	 
);

extern int XChangeKeyboardMapping(
    Display*		 ,
    int			 ,
    int			 ,
    KeySym*		 ,
    int			 
);

extern int XChangePointerControl(
    Display*		 ,
    int		 ,
    int		 ,
    int			 ,
    int			 ,
    int			 
);

extern int XChangeProperty(
    Display*		 ,
    Window		 ,
    Atom		 ,
    Atom		 ,
    int			 ,
    int			 ,
    const unsigned char*	 ,
    int			 
);

extern int XChangeSaveSet(
    Display*		 ,
    Window		 ,
    int			 
);

extern int XChangeWindowAttributes(
    Display*		 ,
    Window		 ,
    unsigned long	 ,
    XSetWindowAttributes*  
);

extern int XCheckIfEvent(
    Display*		 ,
    XEvent*		 ,
    int (*) (
	       Display*			 ,
               XEvent*			 ,
               XPointer			 
             )		 ,
    XPointer		 
);

extern int XCheckMaskEvent(
    Display*		 ,
    long		 ,
    XEvent*		 
);

extern int XCheckTypedEvent(
    Display*		 ,
    int			 ,
    XEvent*		 
);

extern int XCheckTypedWindowEvent(
    Display*		 ,
    Window		 ,
    int			 ,
    XEvent*		 
);

extern int XCheckWindowEvent(
    Display*		 ,
    Window		 ,
    long		 ,
    XEvent*		 
);

extern int XCirculateSubwindows(
    Display*		 ,
    Window		 ,
    int			 
);

extern int XCirculateSubwindowsDown(
    Display*		 ,
    Window		 
);

extern int XCirculateSubwindowsUp(
    Display*		 ,
    Window		 
);

extern int XClearArea(
    Display*		 ,
    Window		 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 ,
    int		 
);

extern int XClearWindow(
    Display*		 ,
    Window		 
);

extern int XCloseDisplay(
    Display*		 
);

extern int XConfigureWindow(
    Display*		 ,
    Window		 ,
    unsigned int	 ,
    XWindowChanges*	 		 
);

extern int XConnectionNumber(
    Display*		 
);

extern int XConvertSelection(
    Display*		 ,
    Atom		 ,
    Atom 		 ,
    Atom		 ,
    Window		 ,
    Time		 
);

extern int XCopyArea(
    Display*		 ,
    Drawable		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 ,
    int			 ,
    int			 
);

extern int XCopyGC(
    Display*		 ,
    GC			 ,
    unsigned long	 ,
    GC			 
);

extern int XCopyPlane(
    Display*		 ,
    Drawable		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 ,
    int			 ,
    int			 ,
    unsigned long	 
);

extern int XDefaultDepth(
    Display*		 ,
    int			 
);

extern int XDefaultDepthOfScreen(
    Screen*		 
);

extern int XDefaultScreen(
    Display*		 
);

extern int XDefineCursor(
    Display*		 ,
    Window		 ,
    Cursor		 
);

extern int XDeleteProperty(
    Display*		 ,
    Window		 ,
    Atom		 
);

extern int XDestroyWindow(
    Display*		 ,
    Window		 
);

extern int XDestroySubwindows(
    Display*		 ,
    Window		 
);

extern int XDoesBackingStore(
    Screen*		     
);

extern int XDoesSaveUnders(
    Screen*		 
);

extern int XDisableAccessControl(
    Display*		 
);


extern int XDisplayCells(
    Display*		 ,
    int			 
);

extern int XDisplayHeight(
    Display*		 ,
    int			 
);

extern int XDisplayHeightMM(
    Display*		 ,
    int			 
);

extern int XDisplayKeycodes(
    Display*		 ,
    int*		 ,
    int*		 
);

extern int XDisplayPlanes(
    Display*		 ,
    int			 
);

extern int XDisplayWidth(
    Display*		 ,
    int			 
);

extern int XDisplayWidthMM(
    Display*		 ,
    int			 
);

extern int XDrawArc(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 ,
    int			 ,
    int			 
);

extern int XDrawArcs(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    XArc*		 ,
    int			 
);

extern int XDrawImageString(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    const char*	 ,
    int			 
);

extern int XDrawImageString16(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    const XChar2b*	 ,
    int			 
);

extern int XDrawLine(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    int			 ,
    int			 
);

extern int XDrawLines(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    XPoint*		 ,
    int			 ,
    int			 
);

extern int XDrawPoint(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 
);

extern int XDrawPoints(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    XPoint*		 ,
    int			 ,
    int			 
);

extern int XDrawRectangle(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 
);

extern int XDrawRectangles(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    XRectangle*		 ,
    int			 
);

extern int XDrawSegments(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    XSegment*		 ,
    int			 
);

extern int XDrawString(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    const char*	 ,
    int			 
);

extern int XDrawString16(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    const XChar2b*	 ,
    int			 
);

extern int XDrawText(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    XTextItem*		 ,
    int			 
);

extern int XDrawText16(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    XTextItem16*	 ,
    int			 
);

extern int XEnableAccessControl(
    Display*		 
);

extern int XEventsQueued(
    Display*		 ,
    int			 
);

extern int XFetchName(
    Display*		 ,
    Window		 ,
    char**		 
);

extern int XFillArc(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 ,
    int			 ,
    int			 
);

extern int XFillArcs(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    XArc*		 ,
    int			 
);

extern int XFillPolygon(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    XPoint*		 ,
    int			 ,
    int			 ,
    int			 
);

extern int XFillRectangle(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 
);

extern int XFillRectangles(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    XRectangle*		 ,
    int			 
);

extern int XFlush(
    Display*		 
);

extern int XForceScreenSaver(
    Display*		 ,
    int			 
);

extern int XFree(
    void*		 
);

extern int XFreeColormap(
    Display*		 ,
    Colormap		 
);

extern int XFreeColors(
    Display*		 ,
    Colormap		 ,
    unsigned long*	 ,
    int			 ,
    unsigned long	 
);

extern int XFreeCursor(
    Display*		 ,
    Cursor		 
);

extern int XFreeExtensionList(
    char**		     
);

extern int XFreeFont(
    Display*		 ,
    XFontStruct*	 
);

extern int XFreeFontInfo(
    char**		 ,
    XFontStruct*	 ,
    int			 
);

extern int XFreeFontNames(
    char**		 
);

extern int XFreeFontPath(
    char**		 
);

extern int XFreeGC(
    Display*		 ,
    GC			 
);

extern int XFreeModifiermap(
    XModifierKeymap*	 
);

extern int XFreePixmap(
    Display*		 ,
    Pixmap		 
);

extern int XGeometry(
    Display*		 ,
    int			 ,
    const char*	 ,
    const char*	 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned int	 ,
    int			 ,
    int			 ,
    int*		 ,
    int*		 ,
    int*		 ,
    int*		 
);

extern int XGetErrorDatabaseText(
    Display*		 ,
    const char*	 ,
    const char*	 ,
    const char*	 ,
    char*		 ,
    int			 
);

extern int XGetErrorText(
    Display*		 ,
    int			 ,
    char*		 ,
    int			 
);

extern int XGetFontProperty(
    XFontStruct*	 ,
    Atom		 ,
    unsigned long*	 
);

extern int XGetGCValues(
    Display*		 ,
    GC			 ,
    unsigned long	 ,
    XGCValues*		 
);

extern int XGetGeometry(
    Display*		 ,
    Drawable		 ,
    Window*		 ,
    int*		 ,
    int*		 ,
    unsigned int*	 ,
    unsigned int*	 ,
    unsigned int*	 ,
    unsigned int*	 
);

extern int XGetIconName(
    Display*		 ,
    Window		 ,
    char**		 
);

extern int XGetInputFocus(
    Display*		 ,
    Window*		 ,
    int*		 
);

extern int XGetKeyboardControl(
    Display*		 ,
    XKeyboardState*	 
);

extern int XGetPointerControl(
    Display*		 ,
    int*		 ,
    int*		 ,
    int*		 
);

extern int XGetPointerMapping(
    Display*		 ,
    unsigned char*	 ,
    int			 
);

extern int XGetScreenSaver(
    Display*		 ,
    int*		 ,
    int*		 ,
    int*		 ,
    int*		 
);

extern int XGetTransientForHint(
    Display*		 ,
    Window		 ,
    Window*		 
);

extern int XGetWindowProperty(
    Display*		 ,
    Window		 ,
    Atom		 ,
    long		 ,
    long		 ,
    int		 ,
    Atom		 ,
    Atom*		 ,
    int*		 ,
    unsigned long*	 ,
    unsigned long*	 ,
    unsigned char**	 
);

extern int XGetWindowAttributes(
    Display*		 ,
    Window		 ,
    XWindowAttributes*	 
);

extern int XGrabButton(
    Display*		 ,
    unsigned int	 ,
    unsigned int	 ,
    Window		 ,
    int		 ,
    unsigned int	 ,
    int			 ,
    int			 ,
    Window		 ,
    Cursor		 
);

extern int XGrabKey(
    Display*		 ,
    int			 ,
    unsigned int	 ,
    Window		 ,
    int		 ,
    int			 ,
    int			 
);

extern int XGrabKeyboard(
    Display*		 ,
    Window		 ,
    int		 ,
    int			 ,
    int			 ,
    Time		 
);

extern int XGrabPointer(
    Display*		 ,
    Window		 ,
    int		 ,
    unsigned int	 ,
    int			 ,
    int			 ,
    Window		 ,
    Cursor		 ,
    Time		 
);

extern int XGrabServer(
    Display*		 
);

extern int XHeightMMOfScreen(
    Screen*		 
);

extern int XHeightOfScreen(
    Screen*		 
);

extern int XIfEvent(
    Display*		 ,
    XEvent*		 ,
    int (*) (
	       Display*			 ,
               XEvent*			 ,
               XPointer			 
             )		 ,
    XPointer		 
);

extern int XImageByteOrder(
    Display*		 
);

extern int XInstallColormap(
    Display*		 ,
    Colormap		 
);

extern KeyCode XKeysymToKeycode(
    Display*		 ,
    KeySym		 
);

extern int XKillClient(
    Display*		 ,
    XID			 
);

extern int XLookupColor(
    Display*		 ,
    Colormap		 ,
    const char*	 ,
    XColor*		 ,
    XColor*		 
);

extern int XLowerWindow(
    Display*		 ,
    Window		 
);

extern int XMapRaised(
    Display*		 ,
    Window		 
);

extern int XMapSubwindows(
    Display*		 ,
    Window		 
);

extern int XMapWindow(
    Display*		 ,
    Window		 
);

extern int XMaskEvent(
    Display*		 ,
    long		 ,
    XEvent*		 
);

extern int XMaxCmapsOfScreen(
    Screen*		 
);

extern int XMinCmapsOfScreen(
    Screen*		 
);

extern int XMoveResizeWindow(
    Display*		 ,
    Window		 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 
);

extern int XMoveWindow(
    Display*		 ,
    Window		 ,
    int			 ,
    int			 
);

extern int XNextEvent(
    Display*		 ,
    XEvent*		 
);

extern int XNoOp(
    Display*		 
);

extern int XParseColor(
    Display*		 ,
    Colormap		 ,
    const char*	 ,
    XColor*		 
);

extern int XParseGeometry(
    const char*	 ,
    int*		 ,
    int*		 ,
    unsigned int*	 ,
    unsigned int*	 
);

extern int XPeekEvent(
    Display*		 ,
    XEvent*		 
);

extern int XPeekIfEvent(
    Display*		 ,
    XEvent*		 ,
    int (*) (
	       Display*		 ,
               XEvent*		 ,
               XPointer		 
             )		 ,
    XPointer		 
);

extern int XPending(
    Display*		 
);

extern int XPlanesOfScreen(
    Screen*		 
);

extern int XProtocolRevision(
    Display*		 
);

extern int XProtocolVersion(
    Display*		 
);


extern int XPutBackEvent(
    Display*		 ,
    XEvent*		 
);

extern int XPutImage(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    XImage*		 ,
    int			 ,
    int			 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 	  
);

extern int XQLength(
    Display*		 
);

extern int XQueryBestCursor(
    Display*		 ,
    Drawable		 ,
    unsigned int         ,
    unsigned int	 ,
    unsigned int*	 ,
    unsigned int*	 
);

extern int XQueryBestSize(
    Display*		 ,
    int			 ,
    Drawable		 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned int*	 ,
    unsigned int*	 
);

extern int XQueryBestStipple(
    Display*		 ,
    Drawable		 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned int*	 ,
    unsigned int*	 
);

extern int XQueryBestTile(
    Display*		 ,
    Drawable		 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned int*	 ,
    unsigned int*	 
);

extern int XQueryColor(
    Display*		 ,
    Colormap		 ,
    XColor*		 
);

extern int XQueryColors(
    Display*		 ,
    Colormap		 ,
    XColor*		 ,
    int			 
);

extern int XQueryExtension(
    Display*		 ,
    const char*	 ,
    int*		 ,
    int*		 ,
    int*		 
);

extern int XQueryKeymap(
    Display*		 ,
    char [32]		 
);

extern int XQueryPointer(
    Display*		 ,
    Window		 ,
    Window*		 ,
    Window*		 ,
    int*		 ,
    int*		 ,
    int*		 ,
    int*		 ,
    unsigned int*        
);

extern int XQueryTextExtents(
    Display*		 ,
    XID			 ,
    const char*	 ,
    int			 ,
    int*		 ,
    int*		 ,
    int*		 ,
    XCharStruct*	     
);

extern int XQueryTextExtents16(
    Display*		 ,
    XID			 ,
    const XChar2b*	 ,
    int			 ,
    int*		 ,
    int*		 ,
    int*		 ,
    XCharStruct*	 
);

extern int XQueryTree(
    Display*		 ,
    Window		 ,
    Window*		 ,
    Window*		 ,
    Window**		 ,
    unsigned int*	 
);

extern int XRaiseWindow(
    Display*		 ,
    Window		 
);

extern int XReadBitmapFile(
    Display*		 ,
    Drawable 		 ,
    const char*	 ,
    unsigned int*	 ,
    unsigned int*	 ,
    Pixmap*		 ,
    int*		 ,
    int*		 
);

extern int XReadBitmapFileData(
    const char*	 ,
    unsigned int*	 ,
    unsigned int*	 ,
    unsigned char**	 ,
    int*		 ,
    int*		 
);

extern int XRebindKeysym(
    Display*		 ,
    KeySym		 ,
    KeySym*		 ,
    int			 ,
    const unsigned char*	 ,
    int			 
);

extern int XRecolorCursor(
    Display*		 ,
    Cursor		 ,
    XColor*		 ,
    XColor*		 
);

extern int XRefreshKeyboardMapping(
    XMappingEvent*	     
);

extern int XRemoveFromSaveSet(
    Display*		 ,
    Window		 
);

extern int XRemoveHost(
    Display*		 ,
    XHostAddress*	 
);

extern int XRemoveHosts(
    Display*		 ,
    XHostAddress*	 ,
    int			 
);

extern int XReparentWindow(
    Display*		 ,
    Window		 ,
    Window		 ,
    int			 ,
    int			 
);

extern int XResetScreenSaver(
    Display*		 
);

extern int XResizeWindow(
    Display*		 ,
    Window		 ,
    unsigned int	 ,
    unsigned int	 
);

extern int XRestackWindows(
    Display*		 ,
    Window*		 ,
    int			 
);

extern int XRotateBuffers(
    Display*		 ,
    int			 
);

extern int XRotateWindowProperties(
    Display*		 ,
    Window		 ,
    Atom*		 ,
    int			 ,
    int			 
);

extern int XScreenCount(
    Display*		 
);

extern int XSelectInput(
    Display*		 ,
    Window		 ,
    long		 
);

extern int XSendEvent(
    Display*		 ,
    Window		 ,
    int		 ,
    long		 ,
    XEvent*		 
);

extern int XSetAccessControl(
    Display*		 ,
    int			 
);

extern int XSetArcMode(
    Display*		 ,
    GC			 ,
    int			 
);

extern int XSetBackground(
    Display*		 ,
    GC			 ,
    unsigned long	 
);

extern int XSetClipMask(
    Display*		 ,
    GC			 ,
    Pixmap		 
);

extern int XSetClipOrigin(
    Display*		 ,
    GC			 ,
    int			 ,
    int			 
);

extern int XSetClipRectangles(
    Display*		 ,
    GC			 ,
    int			 ,
    int			 ,
    XRectangle*		 ,
    int			 ,
    int			 
);

extern int XSetCloseDownMode(
    Display*		 ,
    int			 
);

extern int XSetCommand(
    Display*		 ,
    Window		 ,
    char**		 ,
    int			 
);

extern int XSetDashes(
    Display*		 ,
    GC			 ,
    int			 ,
    const char*	 ,
    int			 
);

extern int XSetFillRule(
    Display*		 ,
    GC			 ,
    int			 
);

extern int XSetFillStyle(
    Display*		 ,
    GC			 ,
    int			 
);

extern int XSetFont(
    Display*		 ,
    GC			 ,
    Font		 
);

extern int XSetFontPath(
    Display*		 ,
    char**		 ,
    int			 	     
);

extern int XSetForeground(
    Display*		 ,
    GC			 ,
    unsigned long	 
);

extern int XSetFunction(
    Display*		 ,
    GC			 ,
    int			 
);

extern int XSetGraphicsExposures(
    Display*		 ,
    GC			 ,
    int		 
);

extern int XSetIconName(
    Display*		 ,
    Window		 ,
    const char*	 
);

extern int XSetInputFocus(
    Display*		 ,
    Window		 ,
    int			 ,
    Time		 
);

extern int XSetLineAttributes(
    Display*		 ,
    GC			 ,
    unsigned int	 ,
    int			 ,
    int			 ,
    int			 
);

extern int XSetModifierMapping(
    Display*		 ,
    XModifierKeymap*	 
);

extern int XSetPlaneMask(
    Display*		 ,
    GC			 ,
    unsigned long	 
);

extern int XSetPointerMapping(
    Display*		 ,
    const unsigned char*	 ,
    int			 
);

extern int XSetScreenSaver(
    Display*		 ,
    int			 ,
    int			 ,
    int			 ,
    int			 
);

extern int XSetSelectionOwner(
    Display*		 ,
    Atom	         ,
    Window		 ,
    Time		 
);

extern int XSetState(
    Display*		 ,
    GC			 ,
    unsigned long 	 ,
    unsigned long	 ,
    int			 ,
    unsigned long	 
);

extern int XSetStipple(
    Display*		 ,
    GC			 ,
    Pixmap		 
);

extern int XSetSubwindowMode(
    Display*		 ,
    GC			 ,
    int			 
);

extern int XSetTSOrigin(
    Display*		 ,
    GC			 ,
    int			 ,
    int			 
);

extern int XSetTile(
    Display*		 ,
    GC			 ,
    Pixmap		 
);

extern int XSetWindowBackground(
    Display*		 ,
    Window		 ,
    unsigned long	 
);

extern int XSetWindowBackgroundPixmap(
    Display*		 ,
    Window		 ,
    Pixmap		 
);

extern int XSetWindowBorder(
    Display*		 ,
    Window		 ,
    unsigned long	 
);

extern int XSetWindowBorderPixmap(
    Display*		 ,
    Window		 ,
    Pixmap		 
);

extern int XSetWindowBorderWidth(
    Display*		 ,
    Window		 ,
    unsigned int	 
);

extern int XSetWindowColormap(
    Display*		 ,
    Window		 ,
    Colormap		 
);

extern int XStoreBuffer(
    Display*		 ,
    const char*	 ,
    int			 ,
    int			 
);

extern int XStoreBytes(
    Display*		 ,
    const char*	 ,
    int			 
);

extern int XStoreColor(
    Display*		 ,
    Colormap		 ,
    XColor*		 
);

extern int XStoreColors(
    Display*		 ,
    Colormap		 ,
    XColor*		 ,
    int			 
);

extern int XStoreName(
    Display*		 ,
    Window		 ,
    const char*	 
);

extern int XStoreNamedColor(
    Display*		 ,
    Colormap		 ,
    const char*	 ,
    unsigned long	 ,
    int			 
);

extern int XSync(
    Display*		 ,
    int		 
);

extern int XTextExtents(
    XFontStruct*	 ,
    const char*	 ,
    int			 ,
    int*		 ,
    int*		 ,
    int*		 ,
    XCharStruct*	 
);

extern int XTextExtents16(
    XFontStruct*	 ,
    const XChar2b*	 ,
    int			 ,
    int*		 ,
    int*		 ,
    int*		 ,
    XCharStruct*	 
);

extern int XTextWidth(
    XFontStruct*	 ,
    const char*	 ,
    int			 
);

extern int XTextWidth16(
    XFontStruct*	 ,
    const XChar2b*	 ,
    int			 
);

extern int XTranslateCoordinates(
    Display*		 ,
    Window		 ,
    Window		 ,
    int			 ,
    int			 ,
    int*		 ,
    int*		 ,
    Window*		 
);

extern int XUndefineCursor(
    Display*		 ,
    Window		 
);

extern int XUngrabButton(
    Display*		 ,
    unsigned int	 ,
    unsigned int	 ,
    Window		 
);

extern int XUngrabKey(
    Display*		 ,
    int			 ,
    unsigned int	 ,
    Window		 
);

extern int XUngrabKeyboard(
    Display*		 ,
    Time		 
);

extern int XUngrabPointer(
    Display*		 ,
    Time		 
);

extern int XUngrabServer(
    Display*		 
);

extern int XUninstallColormap(
    Display*		 ,
    Colormap		 
);

extern int XUnloadFont(
    Display*		 ,
    Font		 
);

extern int XUnmapSubwindows(
    Display*		 ,
    Window		 
);

extern int XUnmapWindow(
    Display*		 ,
    Window		 
);

extern int XVendorRelease(
    Display*		 
);

extern int XWarpPointer(
    Display*		 ,
    Window		 ,
    Window		 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 ,
    int			 ,
    int			 	     
);

extern int XWidthMMOfScreen(
    Screen*		 
);

extern int XWidthOfScreen(
    Screen*		 
);

extern int XWindowEvent(
    Display*		 ,
    Window		 ,
    long		 ,
    XEvent*		 
);

extern int XWriteBitmapFile(
    Display*		 ,
    const char*	 ,
    Pixmap		 ,
    unsigned int	 ,
    unsigned int	 ,
    int			 ,
    int			 		     
);

extern int XSupportsLocale (void);

extern char *XSetLocaleModifiers(
    const char*		 
);

extern XOM XOpenOM(
    Display*			 ,
    struct _XrmHashBucketRec*	 ,
    const char*		 ,
    const char*		 
);

extern int XCloseOM(
    XOM			 
);

extern char *XSetOMValues(
    XOM			 ,
    ...
) ;

extern char *XGetOMValues(
    XOM			 ,
    ...
) ;

extern Display *XDisplayOfOM(
    XOM			 
);

extern char *XLocaleOfOM(
    XOM			 
);

extern XOC XCreateOC(
    XOM			 ,
    ...
) ;

extern void XDestroyOC(
    XOC			 
);

extern XOM XOMOfOC(
    XOC			 
);

extern char *XSetOCValues(
    XOC			 ,
    ...
) ;

extern char *XGetOCValues(
    XOC			 ,
    ...
) ;

extern XFontSet XCreateFontSet(
    Display*		 ,
    const char*	 ,
    char***		 ,
    int*		 ,
    char**		 
);

extern void XFreeFontSet(
    Display*		 ,
    XFontSet		 
);

extern int XFontsOfFontSet(
    XFontSet		 ,
    XFontStruct***	 ,
    char***		 
);

extern char *XBaseFontNameListOfFontSet(
    XFontSet		 
);

extern char *XLocaleOfFontSet(
    XFontSet		 
);

extern int XContextDependentDrawing(
    XFontSet		 
);

extern int XDirectionalDependentDrawing(
    XFontSet		 
);

extern int XContextualDrawing(
    XFontSet		 
);

extern XFontSetExtents *XExtentsOfFontSet(
    XFontSet		 
);

extern int XmbTextEscapement(
    XFontSet		 ,
    const char*	 ,
    int			 
);

extern int XwcTextEscapement(
    XFontSet		 ,
    const wchar_t*	 ,
    int			 
);

extern int Xutf8TextEscapement(
    XFontSet		 ,
    const char*	 ,
    int			 
);

extern int XmbTextExtents(
    XFontSet		 ,
    const char*	 ,
    int			 ,
    XRectangle*		 ,
    XRectangle*		 
);

extern int XwcTextExtents(
    XFontSet		 ,
    const wchar_t*	 ,
    int			 ,
    XRectangle*		 ,
    XRectangle*		 
);

extern int Xutf8TextExtents(
    XFontSet		 ,
    const char*	 ,
    int			 ,
    XRectangle*		 ,
    XRectangle*		 
);

extern int XmbTextPerCharExtents(
    XFontSet		 ,
    const char*	 ,
    int			 ,
    XRectangle*		 ,
    XRectangle*		 ,
    int			 ,
    int*		 ,
    XRectangle*		 ,
    XRectangle*		 
);

extern int XwcTextPerCharExtents(
    XFontSet		 ,
    const wchar_t*	 ,
    int			 ,
    XRectangle*		 ,
    XRectangle*		 ,
    int			 ,
    int*		 ,
    XRectangle*		 ,
    XRectangle*		 
);

extern int Xutf8TextPerCharExtents(
    XFontSet		 ,
    const char*	 ,
    int			 ,
    XRectangle*		 ,
    XRectangle*		 ,
    int			 ,
    int*		 ,
    XRectangle*		 ,
    XRectangle*		 
);

extern void XmbDrawText(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    XmbTextItem*	 ,
    int			 
);

extern void XwcDrawText(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    XwcTextItem*	 ,
    int			 
);

extern void Xutf8DrawText(
    Display*		 ,
    Drawable		 ,
    GC			 ,
    int			 ,
    int			 ,
    XmbTextItem*	 ,
    int			 
);

extern void XmbDrawString(
    Display*		 ,
    Drawable		 ,
    XFontSet		 ,
    GC			 ,
    int			 ,
    int			 ,
    const char*	 ,
    int			 
);

extern void XwcDrawString(
    Display*		 ,
    Drawable		 ,
    XFontSet		 ,
    GC			 ,
    int			 ,
    int			 ,
    const wchar_t*	 ,
    int			 
);

extern void Xutf8DrawString(
    Display*		 ,
    Drawable		 ,
    XFontSet		 ,
    GC			 ,
    int			 ,
    int			 ,
    const char*	 ,
    int			 
);

extern void XmbDrawImageString(
    Display*		 ,
    Drawable		 ,
    XFontSet		 ,
    GC			 ,
    int			 ,
    int			 ,
    const char*	 ,
    int			 
);

extern void XwcDrawImageString(
    Display*		 ,
    Drawable		 ,
    XFontSet		 ,
    GC			 ,
    int			 ,
    int			 ,
    const wchar_t*	 ,
    int			 
);

extern void Xutf8DrawImageString(
    Display*		 ,
    Drawable		 ,
    XFontSet		 ,
    GC			 ,
    int			 ,
    int			 ,
    const char*	 ,
    int			 
);

extern XIM XOpenIM(
    Display*			 ,
    struct _XrmHashBucketRec*	 ,
    char*			 ,
    char*			 
);

extern int XCloseIM(
    XIM  
);

extern char *XGetIMValues(
    XIM  , ...
) ;

extern char *qt_XSetIMValues(
    XIM  , ...
) ;

extern Display *XDisplayOfIM(
    XIM  
);

extern char *XLocaleOfIM(
    XIM  
);

extern XIC XCreateIC(
    XIM  , ...
) ;

extern void XDestroyIC(
    XIC  
);

extern void XSetICFocus(
    XIC  
);

extern void XUnsetICFocus(
    XIC  
);

extern wchar_t *XwcResetIC(
    XIC  
);

extern char *XmbResetIC(
    XIC  
);

extern char *Xutf8ResetIC(
    XIC  
);

extern char *XSetICValues(
    XIC  , ...
) ;

extern char *XGetICValues(
    XIC  , ...
) ;

extern XIM XIMOfIC(
    XIC  
);

extern int XFilterEvent(
    XEvent*	 ,
    Window	 
);

extern int XmbLookupString(
    XIC			 ,
    XKeyPressedEvent*	 ,
    char*		 ,
    int			 ,
    KeySym*		 ,
    int*		 
);

extern int XwcLookupString(
    XIC			 ,
    XKeyPressedEvent*	 ,
    wchar_t*		 ,
    int			 ,
    KeySym*		 ,
    int*		 
);

extern int Xutf8LookupString(
    XIC			 ,
    XKeyPressedEvent*	 ,
    char*		 ,
    int			 ,
    KeySym*		 ,
    int*		 
);

extern XVaNestedList XVaCreateNestedList(
    int  , ...
) ;

 

extern int qt_XRegisterIMInstantiateCallback(
    Display*			 ,
    struct _XrmHashBucketRec*	 ,
    char*			 ,
    char*			 ,
    XIDProc			 ,
    XPointer			 
);

extern int qt_XUnregisterIMInstantiateCallback(
    Display*			 ,
    struct _XrmHashBucketRec*	 ,
    char*			 ,
    char*			 ,
    XIDProc			 ,
    XPointer			 
);

typedef void (*XConnectionWatchProc)(
    Display*			 ,
    XPointer			 ,
    int				 ,
    int			 ,	  
    XPointer*			   
);
    

extern int XInternalConnectionNumbers(
    Display*			 ,
    int**			 ,
    int*			 
);

extern void XProcessInternalConnection(
    Display*			 ,
    int				 
);

extern int XAddConnectionWatch(
    Display*			 ,
    XConnectionWatchProc	 ,
    XPointer			 
);

extern void XRemoveConnectionWatch(
    Display*			 ,
    XConnectionWatchProc	 ,
    XPointer			 
);

extern void XSetAuthorization(
    char *			 ,
    int				 , 
    char *			 ,
    int				 
);

extern int _Xmbtowc(
    wchar_t *			 ,




    char *			 ,
    int				 

);

extern int _Xwctomb(
    char *			 ,
    wchar_t			 
);

}

#line 49 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"




#line 1 "/usr/include/X11/Xutil.h"
 














































 
 




 





 
#line 69 "/usr/include/X11/Xutil.h"




 
typedef struct {
    	long flags;	 
	int x, y;		 
	int width, height;	 
	int min_width, min_height;
	int max_width, max_height;
    	int width_inc, height_inc;
	struct {
		int x;	 
		int y;	 
	} min_aspect, max_aspect;
	int base_width, base_height;		 
	int win_gravity;			 
} XSizeHints;




 

 



#line 106 "/usr/include/X11/Xutil.h"

 




typedef struct {
	long flags;	 
	int input;	
 
	int initial_state;	 
	Pixmap icon_pixmap;	 
	Window icon_window; 	 
	int icon_x, icon_y; 	 
	Pixmap icon_mask;	 
	XID window_group;	 
	 
} XWMHints;

 

#line 137 "/usr/include/X11/Xutil.h"

 






 



			 





 
typedef struct {
    unsigned char *value;		 
    Atom encoding;			 
    int format;				 
    unsigned long nitems;		 
} XTextProperty;





typedef enum {
    XStringStyle,		 
    XCompoundTextStyle,		 
    XTextStyle,			 
    XStdICCTextStyle,		 
     
    XUTF8StringStyle		 
} XICCEncodingStyle;

typedef struct {
	int min_width, min_height;
	int max_width, max_height;
	int width_inc, height_inc;
} XIconSize;

typedef struct {
	char *res_name;
	char *res_class;
} XClassHint;

#line 205 "/usr/include/X11/Xutil.h"



 
#line 220 "/usr/include/X11/Xutil.h"



 
typedef struct _XComposeStatus {
    XPointer compose_ptr;	 
    int chars_matched;		 
} XComposeStatus;



 


















#line 263 "/usr/include/X11/Xutil.h"


 
typedef struct _XRegion *Region; 

 
 



 




 

typedef struct {
  Visual *visual;
  VisualID visualid;
  int screen;
  int depth;

  int c_class;					 



  unsigned long red_mask;
  unsigned long green_mask;
  unsigned long blue_mask;
  int colormap_size;
  int bits_per_rgb;
} XVisualInfo;

#line 308 "/usr/include/X11/Xutil.h"




 
typedef struct {
	Colormap colormap;
	unsigned long red_max;
	unsigned long red_mult;
	unsigned long green_max;
	unsigned long green_mult;
	unsigned long blue_max;
	unsigned long blue_mult;
	unsigned long base_pixel;
	VisualID visualid;		 
	XID killid;			 
} XStandardColormap;






 









 


 





typedef int XContext;




extern "C" {

 

extern XClassHint *XAllocClassHint (
    void
);

extern XIconSize *XAllocIconSize (
    void
);

extern XSizeHints *XAllocSizeHints (
    void
);

extern XStandardColormap *XAllocStandardColormap (
    void
);

extern XWMHints *XAllocWMHints (
    void
);

extern int XClipBox(
    Region		 ,
    XRectangle*		 
);

extern Region XCreateRegion(
    void
);

extern const char *XDefaultString (void);

extern int XDeleteContext(
    Display*		 ,
    XID			 ,
    XContext		 
);

extern int XDestroyRegion(
    Region		 
);

extern int XEmptyRegion(
    Region		 
);

extern int XEqualRegion(
    Region		 ,
    Region		 
);

extern int XFindContext(
    Display*		 ,
    XID			 ,
    XContext		 ,
    XPointer*		 
);

extern int XGetClassHint(
    Display*		 ,
    Window		 ,
    XClassHint*		 
);

extern int XGetIconSizes(
    Display*		 ,
    Window		 ,
    XIconSize**		 ,
    int*		 
);

extern int XGetNormalHints(
    Display*		 ,
    Window		 ,
    XSizeHints*		 
);

extern int XGetRGBColormaps(
    Display*		 ,
    Window		 ,
    XStandardColormap**  ,
    int*		 ,
    Atom		 
);

extern int XGetSizeHints(
    Display*		 ,
    Window		 ,
    XSizeHints*		 ,
    Atom		 
);

extern int XGetStandardColormap(
    Display*		 ,
    Window		 ,
    XStandardColormap*	 ,
    Atom		 			    
);

extern int XGetTextProperty(
    Display*		 ,
    Window		 ,
    XTextProperty*	 ,
    Atom		 
);

extern XVisualInfo *XGetVisualInfo(
    Display*		 ,
    long		 ,
    XVisualInfo*	 ,
    int*		 
);

extern int XGetWMClientMachine(
    Display*		 ,
    Window		 ,
    XTextProperty*	 
);

extern XWMHints *XGetWMHints(
    Display*		 ,
    Window		 		      
);

extern int XGetWMIconName(
    Display*		 ,
    Window		 ,
    XTextProperty*	 
);

extern int XGetWMName(
    Display*		 ,
    Window		 ,
    XTextProperty*	 
);

extern int XGetWMNormalHints(
    Display*		 ,
    Window		 ,
    XSizeHints*		 ,
    long*		  
);

extern int XGetWMSizeHints(
    Display*		 ,
    Window		 ,
    XSizeHints*		 ,
    long*		 ,
    Atom		 
);

extern int XGetZoomHints(
    Display*		 ,
    Window		 ,
    XSizeHints*		 
);

extern int XIntersectRegion(
    Region		 ,
    Region		 ,
    Region		 
);

extern void XConvertCase(
    KeySym		 ,
    KeySym*		 ,
    KeySym*		 
);

extern int XLookupString(
    XKeyEvent*		 ,
    char*		 ,
    int			 ,
    KeySym*		 ,
    XComposeStatus*	 
);

extern int XMatchVisualInfo(
    Display*		 ,
    int			 ,
    int			 ,
    int			 ,
    XVisualInfo*	 
);

extern int XOffsetRegion(
    Region		 ,
    int			 ,
    int			 
);

extern int XPointInRegion(
    Region		 ,
    int			 ,
    int			 
);

extern Region XPolygonRegion(
    XPoint*		 ,
    int			 ,
    int			 
);

extern int XRectInRegion(
    Region		 ,
    int			 ,
    int			 ,
    unsigned int	 ,
    unsigned int	 
);

extern int XSaveContext(
    Display*		 ,
    XID			 ,
    XContext		 ,
    const char*	 
);

extern int XSetClassHint(
    Display*		 ,
    Window		 ,
    XClassHint*		 
);

extern int XSetIconSizes(
    Display*		 ,
    Window		 ,
    XIconSize*		 ,
    int			     
);

extern int XSetNormalHints(
    Display*		 ,
    Window		 ,
    XSizeHints*		 
);

extern void XSetRGBColormaps(
    Display*		 ,
    Window		 ,
    XStandardColormap*	 ,
    int			 ,
    Atom		 
);

extern int XSetSizeHints(
    Display*		 ,
    Window		 ,
    XSizeHints*		 ,
    Atom		 
);

extern int XSetStandardProperties(
    Display*		 ,
    Window		 ,
    const char*	 ,
    const char*	 ,
    Pixmap		 ,
    char**		 ,
    int			 ,
    XSizeHints*		 
);

extern void XSetTextProperty(
    Display*		 ,
    Window		 ,
    XTextProperty*	 ,
    Atom		 
);

extern void XSetWMClientMachine(
    Display*		 ,
    Window		 ,
    XTextProperty*	 
);

extern int XSetWMHints(
    Display*		 ,
    Window		 ,
    XWMHints*		 
);

extern void XSetWMIconName(
    Display*		 ,
    Window		 ,
    XTextProperty*	 
);

extern void XSetWMName(
    Display*		 ,
    Window		 ,
    XTextProperty*	 
);

extern void XSetWMNormalHints(
    Display*		 ,
    Window		 ,
    XSizeHints*		 
);

extern void XSetWMProperties(
    Display*		 ,
    Window		 ,
    XTextProperty*	 ,
    XTextProperty*	 ,
    char**		 ,
    int			 ,
    XSizeHints*		 ,
    XWMHints*		 ,
    XClassHint*		 
);

extern void XmbSetWMProperties(
    Display*		 ,
    Window		 ,
    const char*	 ,
    const char*	 ,
    char**		 ,
    int			 ,
    XSizeHints*		 ,
    XWMHints*		 ,
    XClassHint*		 
);

extern void Xutf8SetWMProperties(
    Display*		 ,
    Window		 ,
    const char*	 ,
    const char*	 ,
    char**		 ,
    int			 ,
    XSizeHints*		 ,
    XWMHints*		 ,
    XClassHint*		 
);

extern void XSetWMSizeHints(
    Display*		 ,
    Window		 ,
    XSizeHints*		 ,
    Atom		 
);

extern int XSetRegion(
    Display*		 ,
    GC			 ,
    Region		 
);

extern void XSetStandardColormap(
    Display*		 ,
    Window		 ,
    XStandardColormap*	 ,
    Atom		 
);

extern int XSetZoomHints(
    Display*		 ,
    Window		 ,
    XSizeHints*		 
);

extern int XShrinkRegion(
    Region		 ,
    int			 ,
    int			 
);

extern int XStringListToTextProperty(
    char**		 ,
    int			 ,
    XTextProperty*	 
);

extern int XSubtractRegion(
    Region		 ,
    Region		 ,
    Region		 
);

extern int XmbTextListToTextProperty(
    Display*		display,
    char**		list,
    int			count,
    XICCEncodingStyle	style,
    XTextProperty*	text_prop_return
);

extern int XwcTextListToTextProperty(
    Display*		display,
    wchar_t**		list,
    int			count,
    XICCEncodingStyle	style,
    XTextProperty*	text_prop_return
);

extern int Xutf8TextListToTextProperty(
    Display*		display,
    char**		list,
    int			count,
    XICCEncodingStyle	style,
    XTextProperty*	text_prop_return
);

extern void XwcFreeStringList(
    wchar_t**		list
);

extern int XTextPropertyToStringList(
    XTextProperty*	 ,
    char***		 ,
    int*		 
);

extern int XmbTextPropertyToTextList(
    Display*		display,
    const XTextProperty* text_prop,
    char***		list_return,
    int*		count_return
);

extern int XwcTextPropertyToTextList(
    Display*		display,
    const XTextProperty* text_prop,
    wchar_t***		list_return,
    int*		count_return
);

extern int Xutf8TextPropertyToTextList(
    Display*		display,
    const XTextProperty* text_prop,
    char***		list_return,
    int*		count_return
);

extern int XUnionRectWithRegion(
    XRectangle*		 ,
    Region		 ,
    Region		 
);

extern int XUnionRegion(
    Region		 ,
    Region		 ,
    Region		 
);

extern int XWMGeometry(
    Display*		 ,
    int			 ,
    const char*	 ,
    const char*	 ,
    unsigned int	 ,
    XSizeHints*		 ,
    int*		 ,
    int*		 ,
    int*		 ,
    int*		 ,
    int*		 
);

extern int XXorRegion(
    Region		 ,
    Region		 ,
    Region		 
);

}

#line 54 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"
#line 1 "/usr/include/X11/Xos.h"





























 
 



 








 

#line 63 "/usr/include/X11/Xos.h"







#line 78 "/usr/include/X11/Xos.h"












 



#line 117 "/usr/include/X11/Xos.h"

#line 134 "/usr/include/X11/Xos.h"



 
#line 146 "/usr/include/X11/Xos.h"



 
#line 1 "/usr/include/fcntl.h"










  



#ident	"@(#)unixsrc:usr/src/common/head/fcntl.h /main/1"

#line 1 "/usr/include/sys/fcntl.h"



#ident	"@(#)unixsrc:usr/src/common/uts/fs/fcntl.h /main/legend/1"
#ident	"$Header: $"


extern "C" {









 

#line 29 "/usr/include/sys/fcntl.h"








 
#line 45 "/usr/include/sys/fcntl.h"






 







 









 
#line 76 "/usr/include/sys/fcntl.h"






























#line 113 "/usr/include/sys/fcntl.h"






 
#line 161 "/usr/include/sys/fcntl.h"

typedef struct



		flock64

{
	short	l_type;
	short	l_whence;
	off64_t	l_start;
	off64_t	l_len;		 
	long	l_sysid;
        pid_t	l_pid;
	long	l_pad[4];	 
} flock64_t;

#line 189 "/usr/include/sys/fcntl.h"

typedef struct flock {
	short	l_type;
	short	l_whence;
	off32_t	l_start;
	off32_t	l_len;		 
	long	l_sysid;
        pid_t	l_pid;
	long	l_pad[4];	 
} flock32_t;




typedef	flock32_t	flock_t;
#line 224 "/usr/include/sys/fcntl.h"






 






 





}
#line 19 "/usr/include/fcntl.h"

#line 36 "/usr/include/fcntl.h"








extern "C" {


extern int	fcntl(int, int, ...);
extern int	open(const char *, int, ...);
extern int	creat(const char *, mode_t);



extern int	open32(const char *, int, ...);
extern int	creat32(const char *, mode_t);
extern int	open64(const char *, int, ...);
extern int	creat64(const char *, mode_t);



}


#line 76 "/usr/include/fcntl.h"

#line 168 "/usr/include/X11/Xos.h"
#line 1 "/usr/include/unistd.h"










  



#ident	"@(#)unixsrc:usr/src/common/head/unistd.h /main/2"

#line 1 "/usr/include/sys/unistd.h"










  




#ident	"@(#)unixsrc:usr/src/common/uts/proc/unistd.h /main/1"
#ident	"$Header: $"


extern "C" {






 

 





#line 41 "/usr/include/sys/unistd.h"

 






#line 119 "/usr/include/sys/unistd.h"

 





 

#line 139 "/usr/include/sys/unistd.h"

#line 148 "/usr/include/sys/unistd.h"

#line 159 "/usr/include/sys/unistd.h"

 

#line 172 "/usr/include/sys/unistd.h"










        }
#line 19 "/usr/include/unistd.h"








































#line 66 "/usr/include/unistd.h"

#line 76 "/usr/include/unistd.h"














extern "C" {


extern int	access(const char *, int);
extern unsigned	alarm(unsigned);
extern int	chdir(const char *);
extern int	chown(const char *, uid_t, gid_t);
extern int	close(int);
extern char	*cuserid(char *);
extern int	dup(int);
extern int	dup2(int, int);
extern int	execl(const char *, const char *, ...);
extern int	execle(const char *, const char *, ...);
extern int	execlp(const char *, const char *, ...);
extern int	execv(const char *, char *const *);
extern int	execve(const char *, char *const *, char *const *);
extern int	execvp(const char *, char *const *);
extern void	_exit(int);
extern pid_t	fork(void);
extern long	fpathconf(int, int);
extern char	*getcwd(char *, size_t);
extern gid_t	getegid(void);
extern uid_t	geteuid(void);
extern gid_t	getgid(void);
extern int	getgroups(int, gid_t *);
extern char	*getlogin(void);
extern pid_t	getpgrp(void);
extern pid_t	getpid(void);
extern pid_t	getppid(void);
extern uid_t	getuid(void);
extern int	isatty(int);
extern int	link(const char *, const char *);
extern n_off_t	lseek(int, n_off_t, int);
extern long	pathconf(const char *, int);
extern int	pause(void);
extern int	pipe(int *);
extern ssize_t	read(int, void *, size_t);
extern int	rmdir(const char *);
extern int	setgid(gid_t);
extern int	setpgid(pid_t, pid_t);
extern pid_t	setsid(void);
extern int	setuid(uid_t);
extern unsigned	sleep(unsigned);
extern long	sysconf(int);
extern pid_t	tcgetpgrp(int);
extern int	tcsetpgrp(int, pid_t);
extern char	*ttyname(int);
extern int	unlink(const char *);
extern ssize_t	write(int, const void *, size_t);

extern int	_xgetlogin_r(char *, size_t);
extern int	_xttyname_r(int, char *, size_t);




extern size_t	confstr(int, char *, size_t);
extern int	getopt(int, char *const*, const char *);
extern char	*optarg;
extern int	optind, opterr, optopt;






extern int	chroot(const char *);
extern char	*crypt(const char *, const char *);
extern char	*ctermid(char *);	 
extern void	encrypt(char *, int);
extern int	fsync(int);
extern char	*getpass(const char *);
extern int	nice(int);
extern void	swab(const void *, void *, ssize_t);







extern int	brk(void *);
extern int	fchown(int, uid_t, gid_t);
extern int	fchdir(int);
extern int	ftruncate(int, n_off_t);
extern int	getdtablesize(void);
extern long	gethostid(void);
extern int	gethostname(char *, size_t);
extern int	getpagesize(void);
extern pid_t	getpgid(pid_t);
extern pid_t	getsid(pid_t);
extern char	*getwd(char *);
extern int	lchown(const char *, uid_t, gid_t);
extern int	lockf(int, int, long);
extern int	readlink(const char *, char *, size_t);


extern void	*sbrk(intptr_t);



extern pid_t	setpgrp(void);
extern int	setregid(gid_t, gid_t);
extern int 	setreuid(uid_t, uid_t);
extern int	symlink(const char *, const char *);
extern void	sync(void);
extern int	truncate(const char *, n_off_t);
extern useconds_t ualarm(useconds_t, useconds_t);
extern int 	usleep(useconds_t);
extern pid_t	vfork(void);







extern int	pthread_atfork(void (*)(void), void (*)(void), void (*)(void));

#line 222 "/usr/include/unistd.h"

#line 231 "/usr/include/unistd.h"

#line 240 "/usr/include/unistd.h"









extern int	ftruncate32(int, off32_t);
extern off32_t	lseek32(int, off32_t, int);
extern ssize_t	pread32(int, void *, size_t, off32_t);
extern ssize_t	pwrite32(int, const void *, size_t, off32_t);
extern int	truncate32(const char *, off32_t);

extern int	ftruncate64(int, off64_t);
extern off64_t	lseek64(int, off64_t, int);
extern ssize_t	pread64(int, void *, size_t, off64_t);
extern ssize_t	pwrite64(int, const void *, size_t, off64_t);
extern int	truncate64(const char *, off64_t);






extern int	acct(const char *);

namespace std { extern "C++" void exit(int); } using std::exit;



extern int	fattach(int, const char *);
extern int	fdetach(const char *);
extern pid_t	fork1(void);
extern pid_t	forkall(void);
extern char	*getpass_r(const char *, char *, size_t);
extern char	*gettxt(const char *, const char *);
extern int	ioctl(int, int, ...);
extern int	mincore(caddr_t, size_t, char *);
extern long	nap(long);
extern ssize_t	pread(int, void *, size_t, n_off_t);
extern void	profil(unsigned short *, unsigned, unsigned, unsigned);
extern int	ptrace(int, pid_t, int, int);
extern ssize_t	pwrite(int, const void *, size_t, n_off_t);
extern int	rename(const char *, const char *);
extern int	setgroups(int, const gid_t *);
extern int	stime(const time_t *);



#line 316 "/usr/include/unistd.h"


}


#line 169 "/usr/include/X11/Xos.h"





 

#line 206 "/usr/include/X11/Xos.h"

#line 1 "/usr/include/sys/time.h"



#ident	"@(#)unixsrc:usr/src/common/uts/svc/time.h /main/1"
#ident	"$Header: $"


extern "C" {









 




 

#line 34 "/usr/include/sys/time.h"












struct timeval {
	long	tv_sec;		 
	long	tv_usec;	 
};





struct timezone {
	int	tz_minuteswest;	 
	int	tz_dsttime;	 
};
#line 70 "/usr/include/sys/time.h"





 















 




struct	itimerval {
	struct	timeval it_interval;	 
	struct	timeval it_value;	 
};





 




typedef struct





		timespec


{



	time_t 		tv_sec;		 




	long		tv_nsec;	 

} timestruc_t;



#line 185 "/usr/include/sys/time.h"

int adjtime(struct timeval *, struct timeval *);
int getitimer(int, struct itimerval *);
int setitimer(int, struct itimerval *, struct itimerval *);
int gettimeofday(struct timeval *, void *);
int settimeofday(struct timeval *, struct timezone *);

#line 1 "/usr/include/time.h"










  



#ident	"@(#)unixsrc:usr/src/common/head/time.h /main/1"






















struct tm
{
	int	tm_sec;
	int	tm_min;
	int	tm_hour;
	int	tm_mday;
	int	tm_mon;
	int	tm_year;
	int	tm_wday;
	int	tm_yday;
	int	tm_isdst;
};

#line 62 "/usr/include/time.h"


extern "C" {


extern clock_t	clock(void);
extern double	difftime(time_t, time_t);
extern time_t	mktime(struct tm *);
extern time_t	time(time_t *);
extern char	*asctime(const struct tm *);
extern char	*ctime (const time_t *);
struct tm	*gmtime(const time_t *);
struct tm	*localtime(const time_t *);
extern size_t	strftime(char *, size_t, const char *, const struct tm *);




extern void	tzset(void);
extern char	*tzname[];
extern long	_sysconf(int);









extern long	timezone;
extern int	daylight;
extern char	*strptime(const char *, const char *, struct tm *);






struct tm	*getdate(const char *);
extern int	getdate_err;





extern char	*asctime_r(const struct tm *, char *);
extern char	*ctime_r(const time_t *, char *);
struct tm	*gmtime_r(const time_t *, struct tm *);
struct tm	*localtime_r(const time_t *, struct tm *);




extern long	altzone;
extern int	cftime(char *, const char *, const time_t *);
extern int	ascftime(char *, const char *, const struct tm *);
extern int	getdate_r(const char *, struct tm *);



}
#line 1 "/usr/include/CC/ctime"

#line 1 "/usr/include/time.h"










  

#line 5 "/usr/include/CC/ctime"



namespace std {
using ::clock_t; using ::size_t;
using ::time_t;  using ::tm;
using ::asctime; using ::clock; using ::ctime;
using ::difftime; using ::gmtime; using ::localtime;
using ::mktime; using ::strftime; using ::time;

}	





 
#line 126 "/usr/include/time.h"



#line 193 "/usr/include/sys/time.h"




        }
#line 240 "/usr/include/X11/Xos.h"





 
#line 255 "/usr/include/X11/Xos.h"













 










#line 293 "/usr/include/X11/Xos.h"

#line 1 "/usr/include/X11/Xarch.h"


























 
 




 

 
#line 42 "/usr/include/X11/Xarch.h"

#line 85 "/usr/include/X11/Xarch.h"









#line 101 "/usr/include/X11/Xarch.h"

#line 119 "/usr/include/X11/Xarch.h"







#line 295 "/usr/include/X11/Xos.h"

#line 55 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"
#line 1 "/usr/include/X11/Xatom.h"






 

#line 77 "/usr/include/X11/Xatom.h"

#line 62 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"


#line 1 "/usr/include/X11/extensions/shape.h"
 
























 

 






#line 44 "/usr/include/X11/extensions/shape.h"




















typedef struct {
    int	type;		     
    unsigned long serial;    
    int send_event;	     
    Display *display;	     
    Window window;	     
    int kind;		     
    int x, y;		     
    unsigned width, height;
    Time time;		     
    int shaped;	     
} XShapeEvent;

extern "C" {

extern int XShapeQueryExtension (
    Display*	 ,
    int*	 ,
    int*	 
);

extern int XShapeQueryVersion (
    Display*	 ,
    int*	 ,
    int*	 
);

extern void XShapeCombineRegion (
    Display*	 ,
    Window	 ,
    int		 ,
    int		 ,
    int		 ,
    Region	 ,
    int		 
);

extern void XShapeCombineRectangles (
    Display*	 ,
    Window	 ,
    int		 ,
    int		 ,
    int		 ,
    XRectangle*	 ,
    int		 ,
    int		 ,
    int		 
);

extern void XShapeCombineMask (
    Display*	 ,
    Window	 ,
    int		 ,
    int		 ,
    int		 ,
    Pixmap	 ,
    int		 
);

extern void XShapeCombineShape (
    Display*	 ,
    Window	 ,
    int		 ,
    int		 ,
    int		 ,
    Window	 ,
    int		 ,
    int		 
);

extern void XShapeOffsetShape (
    Display*	 ,
    Window	 ,
    int		 ,
    int		 ,
    int		 
);

extern int XShapeQueryExtents (
    Display*		 ,
    Window		 ,
    int*		 ,
    int*		 ,
    int*		 ,
    unsigned int*	 ,
    unsigned int*	 ,
    int*		 ,
    int*		 ,
    int*		 ,
    unsigned int*	 ,
    unsigned int*	 
);

extern void XShapeSelectInput (
    Display*		 ,
    Window		 ,
    unsigned long	 
);

extern unsigned long XShapeInputSelected (
    Display*	 ,
    Window	 
);

extern XRectangle *XShapeGetRectangles (
    Display*	 ,
    Window	 ,
    int		 ,
    int*	 ,
    int*	 
);

}



#line 69 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"



#line 1 "/usr/include/X11/extensions/XInput.h"
 













































 
 

 




#line 1 "/usr/include/X11/extensions/XI.h"
 













































 
 

 





#line 113 "/usr/include/X11/extensions/XI.h"



#line 134 "/usr/include/X11/extensions/XI.h"









































#line 181 "/usr/include/X11/extensions/XI.h"










#line 199 "/usr/include/X11/extensions/XI.h"








 




 








#line 228 "/usr/include/X11/extensions/XI.h"

#line 235 "/usr/include/X11/extensions/XI.h"

#line 246 "/usr/include/X11/extensions/XI.h"










 



typedef	unsigned long	XEventClass;






 

typedef struct {
        int   	present;
        short	major_version;
        short	minor_version;
} XExtensionVersion;

#line 57 "/usr/include/X11/extensions/XInput.h"



















#line 85 "/usr/include/X11/extensions/XInput.h"




















































































 

typedef struct 
    {
    int            type;          
    unsigned long  serial;        
    int           send_event;    
    Display        *display;      
    Window         window;        
    XID            deviceid;
    Window         root;          
    Window         subwindow;     
    Time           time;          
    int            x, y;          
    int            x_root;        
    int            y_root;        
    unsigned int   state;         
    unsigned int   keycode;       
    int           same_screen;   
    unsigned int   device_state;  
    unsigned char  axes_count;
    unsigned char  first_axis;
    int            axis_data[6];
    } XDeviceKeyEvent;

typedef XDeviceKeyEvent XDeviceKeyPressedEvent;
typedef XDeviceKeyEvent XDeviceKeyReleasedEvent;






 

typedef struct {
    int           type;          
    unsigned long serial;        
    int          send_event;    
    Display       *display;      
    Window        window;        
    XID           deviceid;
    Window        root;          
    Window        subwindow;     
    Time          time;          
    int           x, y;          
    int           x_root;        
    int           y_root;        
    unsigned int  state;         
    unsigned int  button;        
    int          same_screen;   
    unsigned int  device_state;  
    unsigned char axes_count;
    unsigned char first_axis;
    int           axis_data[6];
    } XDeviceButtonEvent;

typedef XDeviceButtonEvent XDeviceButtonPressedEvent;
typedef XDeviceButtonEvent XDeviceButtonReleasedEvent;






 

typedef struct 
    {
    int           type;         
    unsigned long serial;       
    int          send_event;   
    Display       *display;     
    Window        window;       
    XID           deviceid;
    Window        root;         
    Window        subwindow;    
    Time          time;         
    int           x, y;         
    int           x_root;       
    int           y_root;       
    unsigned int  state;        
    char          is_hint;      
    int          same_screen;  
    unsigned int  device_state;  
    unsigned char axes_count;
    unsigned char first_axis;
    int           axis_data[6];
    } XDeviceMotionEvent;






 

typedef struct 
    {
    int           type;        
    unsigned long serial;      
    int          send_event;  
    Display       *display;    
    Window        window;      
    XID           deviceid;
    int           mode;        
    int           detail;
	



 
    Time                time;
    } XDeviceFocusChangeEvent;

typedef XDeviceFocusChangeEvent XDeviceFocusInEvent;
typedef XDeviceFocusChangeEvent XDeviceFocusOutEvent;






 

typedef struct 
    {
    int             type;               
    unsigned long   serial;     
    int            send_event;  
    Display         *display;   
    Window          window;      
    XID	            deviceid;
    Window          root;            
    Window          subwindow;      
    Time            time;            
    int             x, y;            
    int             x_root, y_root;  
    unsigned int    state;           
    int            same_screen;     
    unsigned int    device_state;  
    unsigned char   axes_count;
    unsigned char   first_axis;
    int             axis_data[6];
    } XProximityNotifyEvent;
typedef XProximityNotifyEvent XProximityInEvent;
typedef XProximityNotifyEvent XProximityOutEvent;






 

typedef struct
    {

    unsigned char	c_class;



    unsigned char	length;
    } XInputClass;

typedef struct {
    int           type;
    unsigned long serial;        
    int          send_event;    
    Display       *display;      
    Window        window;
    XID           deviceid;
    Time          time;
    int           num_classes;
    char	  data[64];
} XDeviceStateNotifyEvent;	

typedef struct {

    unsigned char	c_class;



    unsigned char	length;
    unsigned char	num_valuators;
    unsigned char	mode;
    int        		valuators[6];
} XValuatorStatus;

typedef struct {

    unsigned char	c_class;



    unsigned char	length;
    short		num_keys;
    char        	keys[32];
} XKeyStatus;

typedef struct {

    unsigned char	c_class;



    unsigned char	length;
    short		num_buttons;
    char        	buttons[32];
} XButtonStatus;






 

typedef struct {
    int           type;
    unsigned long serial;        
    int          send_event;    
    Display       *display;      
    Window        window;        
    XID           deviceid;
    Time          time;
    int           request;      
 
    int           first_keycode; 
    int           count;         
} XDeviceMappingEvent;






 

typedef struct {
    int           type;
    unsigned long serial;        
    int          send_event;    
    Display       *display;      
    Window        window;        
    XID           deviceid;
    Time          time;
    int           request;       
} XChangeDeviceNotifyEvent;







 

typedef struct {

     XID            c_class;



     int            length;
     XID            id;
} XFeedbackState;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     click;
    int     percent;
    int     pitch;
    int     duration;
    int     led_mask;
    int     global_auto_repeat;
    char    auto_repeats[32];
} XKbdFeedbackState;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     accelNum;
    int     accelDenom;
    int     threshold;
} XPtrFeedbackState;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     resolution;
    int     minVal;
    int     maxVal;
} XIntegerFeedbackState;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     max_symbols;
    int     num_syms_supported;
    KeySym  *syms_supported;
} XStringFeedbackState;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     percent;
    int     pitch;
    int     duration;
} XBellFeedbackState;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     led_values;
    int     led_mask;
} XLedFeedbackState;

typedef struct {

     XID            c_class;



     int            length;
     XID	    id;
} XFeedbackControl;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     accelNum;
    int     accelDenom;
    int     threshold;
} XPtrFeedbackControl;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     click;
    int     percent;
    int     pitch;
    int     duration;
    int     led_mask;
    int     led_value;
    int     key;
    int     auto_repeat_mode;
} XKbdFeedbackControl;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     num_keysyms;
    KeySym  *syms_to_display;
} XStringFeedbackControl;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     int_to_display;
} XIntegerFeedbackControl;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     percent;
    int     pitch;
    int     duration;
} XBellFeedbackControl;

typedef struct {

    XID     c_class;



    int     length;
    XID     id;
    int     led_mask;
    int     led_values;
} XLedFeedbackControl;





 

typedef struct {
     XID            control;
     int            length;
} XDeviceControl;

typedef struct {
     XID            control;
     int            length;
     int            first_valuator;
     int            num_valuators;
     int            *resolutions;
} XDeviceResolutionControl;

typedef struct {
     XID            control;
     int            length;
     int            num_valuators;
     int            *resolutions;
     int            *min_resolutions;
     int            *max_resolutions;
} XDeviceResolutionState;









 

typedef struct _XAnyClassinfo *XAnyClassPtr;

typedef struct _XAnyClassinfo {

    XID 	c_class;



    int 	length;
    } XAnyClassInfo;

typedef struct _XDeviceInfo *XDeviceInfoPtr;

typedef struct _XDeviceInfo
    {
    XID                 id;        
    Atom                type;
    char                *name;
    int                 num_classes;
    int                 use;
    XAnyClassPtr 	inputclassinfo;
    } XDeviceInfo;

typedef struct _XKeyInfo *XKeyInfoPtr;

typedef struct _XKeyInfo
    {

    XID			c_class;



    int			length;
    unsigned short      min_keycode;
    unsigned short      max_keycode;
    unsigned short      num_keys;
    } XKeyInfo;

typedef struct _XButtonInfo *XButtonInfoPtr;

typedef struct _XButtonInfo {

    XID		c_class;



    int		length;
    short 	num_buttons;
    } XButtonInfo;

typedef struct _XAxisInfo *XAxisInfoPtr;

typedef struct _XAxisInfo {
    int 	resolution;
    int 	min_value;
    int 	max_value;
    } XAxisInfo;

typedef struct _XValuatorInfo *XValuatorInfoPtr;

typedef struct	_XValuatorInfo
    {

    XID			c_class;



    int			length;
    unsigned char       num_axes;
    unsigned char       mode;
    unsigned long       motion_buffer;
    XAxisInfoPtr        axes;
    } XValuatorInfo;










 


typedef struct {
        unsigned char   input_class;
        unsigned char   event_type_base;
} XInputClassInfo;

typedef struct {
        XID                    device_id;
        int                    num_classes;
        XInputClassInfo        *classes;
} XDevice;







 

typedef struct {
        XEventClass     event_type;
        XID             device;
} XEventList;







 

typedef struct {
        Time   time;
        int    *data;
} XDeviceTimeCoord;







 

typedef struct {
        XID		device_id;
        int		num_classes;
        XInputClass	*data;
} XDeviceState;










 

typedef struct {

    unsigned char	c_class;



    unsigned char	length;
    unsigned char	num_valuators;
    unsigned char	mode;
    int        		*valuators;
} XValuatorState;

typedef struct {

    unsigned char	c_class;



    unsigned char	length;
    short		num_keys;
    char        	keys[32];
} XKeyState;

typedef struct {

    unsigned char	c_class;



    unsigned char	length;
    short		num_buttons;
    char        	buttons[32];
} XButtonState;





 

extern "C" {

extern int	XChangeKeyboardDevice(
    Display*		 ,
    XDevice*		 
);

extern int	XChangePointerDevice(
    Display*		 ,
    XDevice*		 ,
    int			 ,
    int			 
);

extern int	XGrabDevice(
    Display*		 ,
    XDevice*		 ,
    Window		 ,
    int		 ,
    int			 ,
    XEventClass*	 ,
    int			 ,
    int			 ,
    Time		 
);

extern int	XUngrabDevice(
    Display*		 ,
    XDevice*		 ,
    Time 		 
);

extern int	XGrabDeviceKey(
    Display*		 ,
    XDevice*		 ,
    unsigned int	 ,
    unsigned int	 ,
    XDevice*		 ,
    Window		 ,
    int		 ,
    unsigned int	 ,
    XEventClass*	 ,
    int			 ,
    int			 
);

extern int	XUngrabDeviceKey(
    Display*		 ,
    XDevice*		 ,
    unsigned int	 ,
    unsigned int	 ,
    XDevice*		 ,
    Window		 
);

extern int	XGrabDeviceButton(
    Display*		 ,
    XDevice*		 ,
    unsigned int	 ,
    unsigned int	 ,
    XDevice*		 ,
    Window		 ,
    int		 ,
    unsigned int	 ,
    XEventClass*	 ,
    int			 ,
    int			 
);

extern int	XUngrabDeviceButton(
    Display*		 ,
    XDevice*		 ,
    unsigned int	 ,
    unsigned int	 ,
    XDevice*		 ,
    Window		 
);

extern int	XAllowDeviceEvents(
    Display*		 ,
    XDevice*		 ,
    int			 ,
    Time		 
);

extern int	XGetDeviceFocus(
    Display*		 ,
    XDevice*		 ,
    Window*		 ,
    int*		 ,
    Time*		 
);

extern int	XSetDeviceFocus(
    Display*		 ,
    XDevice*		 ,
    Window		 ,
    int			 ,
    Time		 
);

extern XFeedbackState	*XGetFeedbackControl(
    Display*		 ,
    XDevice*		 ,
    int*		 
);

extern void	XFreeFeedbackList(
    XFeedbackState*	 
);

extern int	XChangeFeedbackControl(
    Display*		 ,
    XDevice*		 ,
    unsigned long	 ,
    XFeedbackControl*	 
);

extern int	XDeviceBell(
    Display*		 ,
    XDevice*		 ,
    XID			 ,
    XID			 ,
    int			 
);

extern KeySym	*XGetDeviceKeyMapping(
    Display*		 ,
    XDevice*		 ,

    unsigned int	 ,



    int			 ,
    int*		 
);

extern int	XChangeDeviceKeyMapping(
    Display*		 ,
    XDevice*		 ,
    int			 ,
    int			 ,
    KeySym*		 ,
    int			 
);

extern XModifierKeymap	*XGetDeviceModifierMapping(
    Display*		 ,
    XDevice*		 
);

extern int	XSetDeviceModifierMapping(
    Display*		 ,
    XDevice*		 ,
    XModifierKeymap*	 
);

extern int	XSetDeviceButtonMapping(
    Display*		 ,
    XDevice*		 ,
    unsigned char*	 ,
    int			 
);

extern int	XGetDeviceButtonMapping(
    Display*		 ,
    XDevice*		 ,
    unsigned char*	 ,
    unsigned int	 
);

extern XDeviceState	*XQueryDeviceState(
    Display*		 ,
    XDevice*		 
);

extern void	XFreeDeviceState(
    XDeviceState*	 
);

extern XExtensionVersion	*XGetExtensionVersion(
    Display*		 ,
    const char*	 
);

extern XDeviceInfo	*XListInputDevices(
    Display*		 ,
    int*		 
);

extern void	XFreeDeviceList(
    XDeviceInfo*	 
);

extern XDevice	*XOpenDevice(
    Display*		 ,
    XID			 
);

extern int	XCloseDevice(
    Display*		 ,
    XDevice*		 
);

extern int	XSetDeviceMode(
    Display*		 ,
    XDevice*		 ,
    int			 
);

extern int	XSetDeviceValuators(
    Display*		 ,
    XDevice*		 ,
    int*		 ,
    int			 ,
    int			 
);

extern XDeviceControl	*XGetDeviceControl(
    Display*		 ,
    XDevice*		 ,
    int			 
);

extern int	XChangeDeviceControl(
    Display*		 ,
    XDevice*		 ,
    int			 ,
    XDeviceControl*	 
);

extern int	XSelectExtensionEvent(
    Display*		 ,
    Window		 ,
    XEventClass*	 ,
    int			 
);

extern int XGetSelectedExtensionEvents(
    Display*		 ,
    Window		 ,
    int*		 ,
    XEventClass**	 ,
    int*		 ,
    XEventClass**	 
);

extern int	XChangeDeviceDontPropagateList(
    Display*		 ,
    Window		 ,
    int			 ,
    XEventClass*	 ,
    int			 
);

extern XEventClass	*XGetDeviceDontPropagateList(
    Display*		 ,
    Window		 ,
    int*		 
);

extern int	XSendExtensionEvent(
    Display*		 ,
    XDevice*		 ,
    Window		 ,
    int		 ,
    int			 ,
    XEventClass*	 ,
    XEvent*		 
);

extern XDeviceTimeCoord	*XGetDeviceMotionEvents(
    Display*		 ,
    XDevice*		 ,
    Time		 ,
    Time		 ,
    int*		 ,
    int*		 ,
    int*		 
);

extern void	XFreeDeviceMotionEvents(
    XDeviceTimeCoord*	 
);

extern void	XFreeDeviceControl(
    XDeviceControl*	 
);

}

#line 74 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"








#line 119 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"

extern "C" {
#line 1 "/usr/include/X11/extensions/Xinerama.h"
 
























 
 






typedef struct {
   int   screen_number;
   short x_org;
   short y_org;
   short width;
   short height;
} XineramaScreenInfo;

extern "C" {

int XineramaQueryExtension (
   Display *dpy,
   int     *event_base,
   int     *error_base
);

int XineramaQueryVersion(
   Display *dpy,
   int     *major_versionp,
   int     *minor_versionp
);

int XineramaIsActive(Display *dpy);








 

XineramaScreenInfo * 
XineramaQueryScreens(
   Display *dpy,
   int     *number
);

}



#line 122 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"
}




#line 1 "/usr/include/X11/extensions/Xrandr.h"
























 




#line 1 "/usr/include/X11/extensions/randr.h"
























 




typedef unsigned short	Rotation;
typedef unsigned short	SizeID;
typedef unsigned short	SubpixelOrder;









 


 


 



 





 





 









#line 31 "/usr/include/X11/extensions/Xrandr.h"



extern "C" {

    
typedef struct {
    int	width, height;
    int	mwidth, mheight;
} XRRScreenSize;



 

typedef struct {
    int type;			 
    unsigned long serial;	 
    int send_event;		 
    Display *display;		 
    Window window;		 
    Window root;		 
    Time timestamp;		 
    Time config_timestamp;	 
    SizeID size_index;
    SubpixelOrder subpixel_order;
    Rotation rotation;
    int width;
    int height;
    int mwidth;
    int mheight;
} XRRScreenChangeNotifyEvent;


 
typedef struct _XRRScreenConfiguration XRRScreenConfiguration;	

int XRRQueryExtension (Display *dpy, int *event_basep, int *error_basep);
int XRRQueryVersion (Display *dpy,
			    int     *major_versionp,
			    int     *minor_versionp);

XRRScreenConfiguration *XRRGetScreenInfo (Display *dpy,
					  Drawable draw);
    
void XRRFreeScreenConfigInfo (XRRScreenConfiguration *config);







 
int XRRSetScreenConfig (Display *dpy, 
			   XRRScreenConfiguration *config,
			   Drawable draw,
			   int size_index,
			   Rotation rotation,
			   Time timestamp);

 
int XRRSetScreenConfigAndRate (Display *dpy, 
				  XRRScreenConfiguration *config,
				  Drawable draw,
				  int size_index,
				  Rotation rotation,
				  short rate,
				  Time timestamp);


Rotation XRRConfigRotations(XRRScreenConfiguration *config, Rotation *current_rotation);

Time XRRConfigTimes (XRRScreenConfiguration *config, Time *config_timestamp);

XRRScreenSize *XRRConfigSizes(XRRScreenConfiguration *config, int *nsizes);

short *XRRConfigRates (XRRScreenConfiguration *config, int sizeID, int *nrates);

SizeID XRRConfigCurrentConfiguration (XRRScreenConfiguration *config, 
			      Rotation *rotation);
    
short XRRConfigCurrentRate (XRRScreenConfiguration *config);

int XRRRootToScreen(Display *dpy, Window root);







 


XRRScreenConfiguration *XRRScreenConfig(Display *dpy, int screen);
XRRScreenConfiguration *XRRConfig(Screen *screen);
void XRRSelectInput(Display *dpy, Window window, int mask);




 


Rotation XRRRotations(Display *dpy, int screen, Rotation *current_rotation);
XRRScreenSize *XRRSizes(Display *dpy, int screen, int *nsizes);
short *XRRRates (Display *dpy, int screen, int sizeID, int *nrates);
Time XRRTimes (Display *dpy, int screen, Time *config_timestamp);






 
int XRRUpdateConfiguration(XEvent *event);

}

#line 129 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"



#line 1 "/usr/include/X11/extensions/Xrender.h"






















 




#line 1 "/usr/include/X11/extensions/render.h"























 




typedef unsigned long	Glyph;
typedef unsigned long	GlyphSet;
typedef unsigned long	Picture;
typedef unsigned long	PictFormat;





#line 54 "/usr/include/X11/extensions/render.h"
 
#line 65 "/usr/include/X11/extensions/render.h"
 

 



 

 

 






#line 88 "/usr/include/X11/extensions/render.h"




#line 108 "/usr/include/X11/extensions/render.h"



 
#line 126 "/usr/include/X11/extensions/render.h"

#line 141 "/usr/include/X11/extensions/render.h"







#line 162 "/usr/include/X11/extensions/render.h"

 


 








 
#line 182 "/usr/include/X11/extensions/render.h"

 





#line 29 "/usr/include/X11/extensions/Xrender.h"






typedef struct {
    short   red;
    short   redMask;
    short   green;
    short   greenMask;
    short   blue;
    short   blueMask;
    short   alpha;
    short   alphaMask;
} XRenderDirectFormat;

typedef struct {
    PictFormat		id;
    int			type;
    int			depth;
    XRenderDirectFormat	direct;
    Colormap		colormap;
} XRenderPictFormat;

#line 66 "/usr/include/X11/extensions/Xrender.h"

typedef struct _XRenderPictureAttributes {
    int 		repeat;
    Picture		alpha_map;
    int			alpha_x_origin;
    int			alpha_y_origin;
    int			clip_x_origin;
    int			clip_y_origin;
    Pixmap		clip_mask;
    int		graphics_exposures;
    int			subwindow_mode;
    int			poly_edge;
    int			poly_mode;
    Atom		dither;
    int		component_alpha;
} XRenderPictureAttributes;

typedef struct {
    unsigned short   red;
    unsigned short   green;
    unsigned short   blue;
    unsigned short   alpha;
} XRenderColor;

typedef struct _XGlyphInfo {
    unsigned short  width;
    unsigned short  height;
    short	    x;
    short	    y;
    short	    xOff;
    short	    yOff;
} XGlyphInfo;

typedef struct _XGlyphElt8 {
    GlyphSet		    glyphset;
    const char	    *chars;
    int			    nchars;
    int			    xOff;
    int			    yOff;
} XGlyphElt8;

typedef struct _XGlyphElt16 {
    GlyphSet		    glyphset;
    const unsigned short  *chars;
    int			    nchars;
    int			    xOff;
    int			    yOff;
} XGlyphElt16;

typedef struct _XGlyphElt32 {
    GlyphSet		    glyphset;
    const unsigned int    *chars;
    int			    nchars;
    int			    xOff;
    int			    yOff;
} XGlyphElt32;

typedef double	XDouble;

typedef struct _XPointDouble {
    XDouble  x, y;
} XPointDouble;




typedef int XFixed;

typedef struct _XPointFixed {
    XFixed  x, y;
} XPointFixed;

typedef struct _XLineFixed {
    XPointFixed	p1, p2;
} XLineFixed;

typedef struct _XTriangle {
    XPointFixed	p1, p2, p3;
} XTriangle;

typedef struct _XCircle {
    XFixed x;
    XFixed y;
    XFixed radius;
} XCircle;

typedef struct _XTrapezoid {
    XFixed  top, bottom;
    XLineFixed	left, right;
} XTrapezoid;

typedef struct _XTransform {
    XFixed  matrix[3][3];
} XTransform;

typedef struct _XFilters {
    int	    nfilter;
    char    **filter;
    int	    nalias;
    short   *alias;
} XFilters;

typedef struct _XIndexValue {
    unsigned long    pixel;
    unsigned short   red, green, blue, alpha;
} XIndexValue;

typedef struct _XAnimCursor {
    Cursor	    cursor;
    unsigned long   delay;
} XAnimCursor;

typedef struct _XSpanFix {
    XFixed	    left, right, y;
} XSpanFix;

typedef struct _XTrap {
    XSpanFix	    top, bottom;
} XTrap;

typedef struct _XLinearGradient {
    XPointFixed p1;
    XPointFixed p2;
} XLinearGradient;

typedef struct _XRadialGradient {
    XCircle inner;
    XCircle outer;
} XRadialGradient;

typedef struct _XConicalGradient {
    XPointFixed center;
    XFixed angle;  
} XConicalGradient;

extern "C" {

int XRenderQueryExtension (Display *dpy, int *event_basep, int *error_basep);

int XRenderQueryVersion (Display *dpy,
			    int     *major_versionp,
			    int     *minor_versionp);

int XRenderQueryFormats (Display *dpy);

int XRenderQuerySubpixelOrder (Display *dpy, int screen);

int XRenderSetSubpixelOrder (Display *dpy, int screen, int subpixel);

XRenderPictFormat *
XRenderFindVisualFormat (Display *dpy, const Visual *visual);

XRenderPictFormat *
XRenderFindFormat (Display			*dpy,
		   unsigned long		mask,
		   const XRenderPictFormat	*templ,
		   int				count);
    
#line 230 "/usr/include/X11/extensions/Xrender.h"

XRenderPictFormat *
XRenderFindStandardFormat (Display		*dpy,
			   int			format);

XIndexValue *
XRenderQueryPictIndexValues(Display			*dpy,
			    const XRenderPictFormat	*format,
			    int				*num);

Picture
XRenderCreatePicture (Display				*dpy,
		      Drawable				drawable,
		      const XRenderPictFormat		*format,
		      unsigned long			valuemask,
		      const XRenderPictureAttributes	*attributes);

void
XRenderChangePicture (Display				*dpy,
		      Picture				picture,
		      unsigned long			valuemask,
		      const XRenderPictureAttributes  *attributes);

void
XRenderSetPictureClipRectangles (Display	    *dpy,
				 Picture	    picture,
				 int		    xOrigin,
				 int		    yOrigin,
				 const XRectangle *rects,
				 int		    n);

void
XRenderSetPictureClipRegion (Display	    *dpy,
			     Picture	    picture,
			     Region	    r);

void
XRenderSetPictureTransform (Display	    *dpy,
			    Picture	    picture,
			    XTransform	    *transform);

void
XRenderFreePicture (Display                   *dpy,
		    Picture                   picture);

void
XRenderComposite (Display   *dpy,
		  int	    op,
		  Picture   src,
		  Picture   mask,
		  Picture   dst,
		  int	    src_x,
		  int	    src_y,
		  int	    mask_x,
		  int	    mask_y,
		  int	    dst_x,
		  int	    dst_y,
		  unsigned int	width,
		  unsigned int	height);

GlyphSet
XRenderCreateGlyphSet (Display *dpy, const XRenderPictFormat *format);

GlyphSet
XRenderReferenceGlyphSet (Display *dpy, GlyphSet existing);

void
XRenderFreeGlyphSet (Display *dpy, GlyphSet glyphset);

void
XRenderAddGlyphs (Display		*dpy,
		  GlyphSet		glyphset,
		  const Glyph		*gids,
		  const XGlyphInfo	*glyphs,
		  int			nglyphs,
		  const char		*images,
		  int			nbyte_images);

void
XRenderFreeGlyphs (Display	    *dpy,
		   GlyphSet	    glyphset,
		   const Glyph    *gids,
		   int		    nglyphs);

void
XRenderCompositeString8 (Display		    *dpy,
			 int			    op,
			 Picture		    src,
			 Picture		    dst,
			 const XRenderPictFormat  *maskFormat,
			 GlyphSet		    glyphset,
			 int			    xSrc,
			 int			    ySrc,
			 int			    xDst,
			 int			    yDst,
			 const char		    *string,
			 int			    nchar);

void
XRenderCompositeString16 (Display		    *dpy,
			  int			    op,
			  Picture		    src,
			  Picture		    dst,
			  const XRenderPictFormat *maskFormat,
			  GlyphSet		    glyphset,
			  int			    xSrc,
			  int			    ySrc,
			  int			    xDst,
			  int			    yDst,
			  const unsigned short    *string,
			  int			    nchar);

void
XRenderCompositeString32 (Display		    *dpy,
			  int			    op,
			  Picture		    src,
			  Picture		    dst,
			  const XRenderPictFormat *maskFormat,
			  GlyphSet		    glyphset,
			  int			    xSrc,
			  int			    ySrc,
			  int			    xDst,
			  int			    yDst,
			  const unsigned int	    *string,
			  int			    nchar);

void
XRenderCompositeText8 (Display			    *dpy,
		       int			    op,
		       Picture			    src,
		       Picture			    dst,
		       const XRenderPictFormat    *maskFormat,
		       int			    xSrc,
		       int			    ySrc,
		       int			    xDst,
		       int			    yDst,
		       const XGlyphElt8	    *elts,
		       int			    nelt);

void
XRenderCompositeText16 (Display			    *dpy,
			int			    op,
			Picture			    src,
			Picture			    dst,
			const XRenderPictFormat   *maskFormat,
			int			    xSrc,
			int			    ySrc,
			int			    xDst,
			int			    yDst,
			const XGlyphElt16	    *elts,
			int			    nelt);

void
XRenderCompositeText32 (Display			    *dpy,
			int			    op,
			Picture			    src,
			Picture			    dst,
			const XRenderPictFormat   *maskFormat,
			int			    xSrc,
			int			    ySrc,
			int			    xDst,
			int			    yDst,
			const XGlyphElt32	    *elts,
			int			    nelt);

void
XRenderFillRectangle (Display		    *dpy,
		      int		    op,
		      Picture		    dst,
		      const XRenderColor  *color,
		      int		    x,
		      int		    y,
		      unsigned int	    width,
		      unsigned int	    height);

void
XRenderFillRectangles (Display		    *dpy,
		       int		    op,
		       Picture		    dst,
		       const XRenderColor *color,
		       const XRectangle   *rectangles,
		       int		    n_rects);

void
XRenderCompositeTrapezoids (Display		*dpy,
			    int			op,
			    Picture		src,
			    Picture		dst,
			    const XRenderPictFormat	*maskFormat,
			    int			xSrc,
			    int			ySrc,
			    const XTrapezoid	*traps,
			    int			ntrap);

void
XRenderCompositeTriangles (Display		*dpy,
			   int			op,
			   Picture		src,
			   Picture		dst,
			    const XRenderPictFormat	*maskFormat,
			   int			xSrc,
			   int			ySrc,
			   const XTriangle	*triangles,
			   int			ntriangle);

void
XRenderCompositeTriStrip (Display		*dpy,
			  int			op,
			  Picture		src,
			  Picture		dst,
			    const XRenderPictFormat	*maskFormat,
			  int			xSrc,
			  int			ySrc,
			  const XPointFixed	*points,
			  int			npoint);

void
XRenderCompositeTriFan (Display			*dpy,
			int			op,
			Picture			src,
			Picture			dst,
			const XRenderPictFormat	*maskFormat,
			int			xSrc,
			int			ySrc,
			const XPointFixed	*points,
			int			npoint);

void
XRenderCompositeDoublePoly (Display		    *dpy,
			    int			    op,
			    Picture		    src,
			    Picture		    dst,
			    const XRenderPictFormat	*maskFormat,
			    int			    xSrc,
			    int			    ySrc,
			    int			    xDst,
			    int			    yDst,
			    const XPointDouble    *fpoints,
			    int			    npoints,
			    int			    winding);
int
XRenderParseColor(Display	*dpy, 
		  char		*spec,
		  XRenderColor	*def);

Cursor
XRenderCreateCursor (Display	    *dpy,
		     Picture	    source,
		     unsigned int   x,
		     unsigned int   y);

XFilters *
XRenderQueryFilters (Display *dpy, Drawable drawable);

void
XRenderSetPictureFilter (Display    *dpy,
			 Picture    picture,
			 char	    *filter,
			 XFixed	    *params,
			 int	    nparams);

Cursor
XRenderCreateAnimCursor (Display	*dpy,
			 int		ncursor,
			 XAnimCursor	*cursors);


void
XRenderAddTraps (Display	    *dpy,
		 Picture	    picture,
		 int		    xOff,
		 int		    yOff,
		 const XTrap	    *traps,
		 int		    ntrap);

Picture XRenderCreateSolidFill (Display *dpy,
                                const XRenderColor *color);

Picture XRenderCreateLinearGradient (Display *dpy,
                                     const XLinearGradient *gradient,
                                     const XFixed *stops,
                                     const XRenderColor *colors,
                                     int nstops);

Picture XRenderCreateRadialGradient (Display *dpy,
                                     const XRadialGradient *gradient,
                                     const XFixed *stops,
                                     const XRenderColor *colors,
                                     int nstops);

Picture XRenderCreateConicalGradient (Display *dpy,
                                      const XConicalGradient *gradient,
                                      const XFixed *stops,
                                      const XRenderColor *colors,
                                      int nstops);

}

#line 134 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"
#line 140 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"


#line 1 "/usr/include/X11/XKBlib.h"
 
























 
 




#line 1 "/usr/include/X11/extensions/XKBstr.h"
 
























 




#line 1 "/usr/include/X11/extensions/XKB.h"
 
























 
 




    



 
#line 63 "/usr/include/X11/extensions/XKB.h"

    


 



    





 
#line 90 "/usr/include/X11/extensions/XKB.h"

    


 
#line 108 "/usr/include/X11/extensions/XKB.h"

    

 





    



 
#line 129 "/usr/include/X11/extensions/XKB.h"

    



 
#line 143 "/usr/include/X11/extensions/XKB.h"

    



 
#line 157 "/usr/include/X11/extensions/XKB.h"

    











 







    


 
#line 190 "/usr/include/X11/extensions/XKB.h"

    





 
#line 213 "/usr/include/X11/extensions/XKB.h"

    


























 
#line 260 "/usr/include/X11/extensions/XKB.h"







    







 
#line 291 "/usr/include/X11/extensions/XKB.h"

    

























 
#line 326 "/usr/include/X11/extensions/XKB.h"

#line 340 "/usr/include/X11/extensions/XKB.h"















    



 
#line 366 "/usr/include/X11/extensions/XKB.h"

#line 373 "/usr/include/X11/extensions/XKB.h"

    





 




    






 




    




























 
















#line 449 "/usr/include/X11/extensions/XKB.h"











    




 
#line 476 "/usr/include/X11/extensions/XKB.h"

    


 
#line 504 "/usr/include/X11/extensions/XKB.h"





    

 





	 
    

 





    






 











    

 




 


    

 
#line 570 "/usr/include/X11/extensions/XKB.h"






    

 
#line 586 "/usr/include/X11/extensions/XKB.h"










    

 




    




 
#line 619 "/usr/include/X11/extensions/XKB.h"

    








 
#line 638 "/usr/include/X11/extensions/XKB.h"





    


 



    



 
#line 662 "/usr/include/X11/extensions/XKB.h"

    




 




    




 











    


 




    





 
#line 721 "/usr/include/X11/extensions/XKB.h"

    



 
#line 737 "/usr/include/X11/extensions/XKB.h"

     

 










    









 
#line 770 "/usr/include/X11/extensions/XKB.h"




    


 
#line 784 "/usr/include/X11/extensions/XKB.h"

    

 


#line 32 "/usr/include/X11/extensions/XKBstr.h"




#line 42 "/usr/include/X11/extensions/XKBstr.h"

	

 

typedef struct _XkbStateRec {
	unsigned char	group;
	unsigned char   locked_group;
	unsigned short	base_group;
	unsigned short	latched_group;
	unsigned char	mods;
	unsigned char	base_mods;
	unsigned char	latched_mods;
	unsigned char	locked_mods;
	unsigned char	compat_state;
	unsigned char	grab_mods;
	unsigned char	compat_grab_mods;
	unsigned char	lookup_mods;
	unsigned char	compat_lookup_mods;
	unsigned short	ptr_buttons;
} XkbStateRec,*XkbStatePtr;
#line 69 "/usr/include/X11/extensions/XKBstr.h"

typedef struct _XkbMods {
	unsigned char	mask;	 
	unsigned char	real_mods;
	unsigned short	vmods;
} XkbModsRec,*XkbModsPtr;

typedef struct _XkbKTMapEntry {
	int		active;
	unsigned char	level;
	XkbModsRec	mods;
} XkbKTMapEntryRec,*XkbKTMapEntryPtr;

typedef struct _XkbKeyType {
	XkbModsRec		mods;
	unsigned char	  	num_levels;
	unsigned char	  	map_count;
	XkbKTMapEntryPtr  	map;
	XkbModsPtr  		preserve;
	Atom		  	name;
	Atom *			level_names;
} XkbKeyTypeRec, *XkbKeyTypePtr;

#line 98 "/usr/include/X11/extensions/XKBstr.h"

	

 

typedef struct _XkbBehavior {
	unsigned char	type;
	unsigned char	data;
} XkbBehavior;


typedef	struct _XkbAnyAction {
	unsigned char	type;
	unsigned char	data[7];
} XkbAnyAction;

typedef struct _XkbModAction {
	unsigned char	type;
	unsigned char	flags;
	unsigned char	mask;
	unsigned char	real_mods;
	unsigned char	vmods1;
	unsigned char	vmods2;
} XkbModAction;





typedef struct _XkbGroupAction {
	unsigned char	type;
	unsigned char	flags;
	char		group_XXX;
} XkbGroupAction;



typedef struct _XkbISOAction {
	unsigned char	type;
	unsigned char	flags;
	unsigned char	mask;
	unsigned char	real_mods;
	char		group_XXX;
	unsigned char	affect;
	unsigned char	vmods1;
	unsigned char	vmods2;
} XkbISOAction;

typedef struct _XkbPtrAction {
	unsigned char	type;
	unsigned char	flags;
	unsigned char	high_XXX;
	unsigned char	low_XXX;
	unsigned char	high_YYY;
	unsigned char	low_YYY;
} XkbPtrAction;





typedef struct _XkbPtrBtnAction {
	unsigned char	type;
	unsigned char	flags;
	unsigned char	count;
	unsigned char	button;
} XkbPtrBtnAction;

typedef struct _XkbPtrDfltAction {
	unsigned char	type;
	unsigned char	flags;
	unsigned char	affect;
	char		valueXXX;
} XkbPtrDfltAction;



typedef struct _XkbSwitchScreenAction {
	unsigned char	type;
	unsigned char	flags;
	char		screenXXX;
} XkbSwitchScreenAction;



typedef struct _XkbCtrlsAction {
	unsigned char	type;
	unsigned char	flags;
	unsigned char	ctrls3;
	unsigned char	ctrls2;
	unsigned char	ctrls1;
	unsigned char	ctrls0;
} XkbCtrlsAction;
#line 199 "/usr/include/X11/extensions/XKBstr.h"

typedef struct _XkbMessageAction {
	unsigned char	type;
	unsigned char	flags;
	unsigned char	message[6];
} XkbMessageAction;

typedef struct	_XkbRedirectKeyAction {
	unsigned char	type;
	unsigned char	new_key;
	unsigned char	mods_mask;
	unsigned char	mods;
	unsigned char	vmods_mask0;
	unsigned char	vmods_mask1;
	unsigned char	vmods0;
	unsigned char	vmods1;
} XkbRedirectKeyAction;

#line 225 "/usr/include/X11/extensions/XKBstr.h"

typedef struct _XkbDeviceBtnAction {
	unsigned char	type;
	unsigned char	flags;
	unsigned char	count;
	unsigned char	button;
	unsigned char	device;
} XkbDeviceBtnAction;

typedef struct _XkbDeviceValuatorAction {
	unsigned char	type;
	unsigned char	device;
	unsigned char	v1_what;
	unsigned char	v1_ndx;
	unsigned char	v1_value;
	unsigned char	v2_what;
	unsigned char	v2_ndx;
	unsigned char	v2_value;
} XkbDeviceValuatorAction;

typedef	union _XkbAction {
	XkbAnyAction		any;
	XkbModAction		mods;
	XkbGroupAction		group;
	XkbISOAction		iso;
	XkbPtrAction		ptr;
	XkbPtrBtnAction		btn;
	XkbPtrDfltAction	dflt;
	XkbSwitchScreenAction	screen;
	XkbCtrlsAction		ctrls;
	XkbMessageAction	msg;
	XkbRedirectKeyAction	redirect;
	XkbDeviceBtnAction	devbtn;
	XkbDeviceValuatorAction	devval;
	unsigned char 		type;
} XkbAction;

typedef	struct _XkbControls {
	unsigned char	mk_dflt_btn;
	unsigned char	num_groups;
	unsigned char	groups_wrap;
	XkbModsRec	internal;
	XkbModsRec	ignore_lock;
	unsigned int	enabled_ctrls;
	unsigned short	repeat_delay;
	unsigned short	repeat_interval;
	unsigned short	slow_keys_delay;
	unsigned short	debounce_delay;
	unsigned short	mk_delay;
	unsigned short	mk_interval;
	unsigned short	mk_time_to_max;
	unsigned short	mk_max_speed;
		 short	mk_curve;
	unsigned short	ax_options;
	unsigned short	ax_timeout;
	unsigned short	axt_opts_mask;
	unsigned short	axt_opts_values;
	unsigned int	axt_ctrls_mask;
	unsigned int	axt_ctrls_values;
	unsigned char	per_key_repeat[((255+1)/8)];
} XkbControlsRec, *XkbControlsPtr;





typedef struct _XkbServerMapRec {
	unsigned short		 num_acts;
	unsigned short		 size_acts;
	XkbAction		*acts;

	XkbBehavior		*behaviors;
	unsigned short		*key_acts;

	 
	unsigned char		*c_explicit;



	unsigned char		 vmods[16];
	unsigned short		*vmodmap;
} XkbServerMapRec, *XkbServerMapPtr;



	

 

typedef	struct _XkbSymMapRec {
	unsigned char	 kt_index[4];
	unsigned char	 group_info;
	unsigned char	 width;
	unsigned short	 offset;
} XkbSymMapRec, *XkbSymMapPtr;

typedef struct _XkbClientMapRec {
	unsigned char		 size_types;
	unsigned char		 num_types;
	XkbKeyTypePtr		 types;

	unsigned short		 size_syms;
	unsigned short		 num_syms;
	KeySym			*syms;
	XkbSymMapPtr		 key_sym_map;

	unsigned char		*modmap;
} XkbClientMapRec, *XkbClientMapPtr;

#line 343 "/usr/include/X11/extensions/XKBstr.h"

	

 

typedef struct _XkbSymInterpretRec {
	KeySym		sym;
	unsigned char	flags;
	unsigned char	match;
	unsigned char	mods;
	unsigned char	virtual_mod;
	XkbAnyAction	act;
} XkbSymInterpretRec,*XkbSymInterpretPtr;

typedef struct _XkbCompatMapRec {
	XkbSymInterpretPtr	 sym_interpret;
	XkbModsRec		 groups[4];
	unsigned short		 num_si;
	unsigned short		 size_si;
} XkbCompatMapRec, *XkbCompatMapPtr;

typedef struct _XkbIndicatorMapRec {
	unsigned char	flags;
	unsigned char	which_groups;
	unsigned char	groups;
	unsigned char	which_mods;
	XkbModsRec	mods;
	unsigned int	ctrls;
} XkbIndicatorMapRec, *XkbIndicatorMapPtr;

#line 379 "/usr/include/X11/extensions/XKBstr.h"
	

typedef struct _XkbIndicatorRec {
	unsigned long	  	phys_indicators;
	XkbIndicatorMapRec	maps[32];
} XkbIndicatorRec,*XkbIndicatorPtr;

typedef	struct _XkbKeyNameRec {
	char	name[4];
} XkbKeyNameRec,*XkbKeyNamePtr;

typedef struct _XkbKeyAliasRec {
	char	real[4];
	char	alias[4];
} XkbKeyAliasRec,*XkbKeyAliasPtr;

	

 
typedef struct _XkbNamesRec {
	Atom		  keycodes;
	Atom		  geometry;
	Atom		  symbols;
	Atom              types;
	Atom		  compat;
	Atom		  vmods[16];
	Atom		  indicators[32];
	Atom		  groups[4];
	XkbKeyNamePtr	  keys;
	XkbKeyAliasPtr	  key_aliases;
	Atom		 *radio_groups;
	Atom		  phys_symbols;

	unsigned char	  num_keys;
	unsigned char	  num_key_aliases;
	unsigned short	  num_rg;
} XkbNamesRec,*XkbNamesPtr;

typedef	struct _XkbGeometry	*XkbGeometryPtr;
	

 
typedef	struct _XkbDesc {
	struct _XDisplay *	dpy;
	unsigned short	 	flags;
	unsigned short		device_spec;
	KeyCode			min_key_code;
	KeyCode			max_key_code;

	XkbControlsPtr		ctrls;
	XkbServerMapPtr		server;
	XkbClientMapPtr		map;
	XkbIndicatorPtr		indicators;
	XkbNamesPtr		names;
	XkbCompatMapPtr		compat;
	XkbGeometryPtr		geom;
} XkbDescRec, *XkbDescPtr;
#line 452 "/usr/include/X11/extensions/XKBstr.h"

#line 459 "/usr/include/X11/extensions/XKBstr.h"


	


 
typedef struct _XkbMapChanges {
	unsigned short		 changed;
	KeyCode			 min_key_code;
	KeyCode			 max_key_code;
	unsigned char		 first_type;
	unsigned char		 num_types;
	KeyCode			 first_key_sym;
	unsigned char		 num_key_syms;
	KeyCode			 first_key_act;
	unsigned char		 num_key_acts;
	KeyCode			 first_key_behavior;
	unsigned char		 num_key_behaviors;
	KeyCode 		 first_key_explicit;
	unsigned char		 num_key_explicit;
	KeyCode			 first_modmap_key;
	unsigned char		 num_modmap_keys;
	KeyCode			 first_vmodmap_key;
	unsigned char		 num_vmodmap_keys;
	unsigned char		 pad;
	unsigned short		 vmods;
} XkbMapChangesRec,*XkbMapChangesPtr;

typedef struct _XkbControlsChanges {
	unsigned int 		 changed_ctrls;
	unsigned int		 enabled_ctrls_changes;
	int			 num_groups_changed;
} XkbControlsChangesRec,*XkbControlsChangesPtr;

typedef struct _XkbIndicatorChanges {
	unsigned int		 state_changes;
	unsigned int		 map_changes;
} XkbIndicatorChangesRec,*XkbIndicatorChangesPtr;

typedef struct _XkbNameChanges {
	unsigned int 		changed;
	unsigned char		first_type;
	unsigned char		num_types;
	unsigned char		first_lvl;
	unsigned char		num_lvls;
	unsigned char		num_aliases;
	unsigned char		num_rg;
	unsigned char		first_key;
	unsigned char		num_keys;
	unsigned short		changed_vmods;
	unsigned long		changed_indicators;
	unsigned char		changed_groups;
} XkbNameChangesRec,*XkbNameChangesPtr;

typedef struct _XkbCompatChanges {
	unsigned char		changed_groups;
	unsigned short		first_si;
	unsigned short		num_si;
} XkbCompatChangesRec,*XkbCompatChangesPtr;

typedef struct _XkbChanges {
	unsigned short		 device_spec;
	unsigned short		 state_changes;
	XkbMapChangesRec	 map;
	XkbControlsChangesRec	 ctrls;
	XkbIndicatorChangesRec	 indicators;
	XkbNameChangesRec	 names;
	XkbCompatChangesRec	 compat;
} XkbChangesRec, *XkbChangesPtr;

	



 
typedef struct _XkbComponentNames {
	char *			 keymap;
	char *			 keycodes;
	char *			 types;
	char *			 compat;
	char *			 symbols;
	char *			 geometry;
} XkbComponentNamesRec, *XkbComponentNamesPtr;

typedef struct _XkbComponentName {
	unsigned short		flags;
	char *			name;
} XkbComponentNameRec,*XkbComponentNamePtr;

typedef struct _XkbComponentList {
	int			num_keymaps;
	int			num_keycodes;
	int			num_types;
	int			num_compat;
	int			num_symbols;
	int			num_geometry;
	XkbComponentNamePtr	keymaps;
	XkbComponentNamePtr 	keycodes;
	XkbComponentNamePtr	types;
	XkbComponentNamePtr	compat;
	XkbComponentNamePtr	symbols;
	XkbComponentNamePtr	geometry;
} XkbComponentListRec, *XkbComponentListPtr;

	


 
typedef struct _XkbDeviceLedInfo {
	unsigned short			led_class;
	unsigned short			led_id;
	unsigned int			phys_indicators;
	unsigned int			maps_present;
	unsigned int			names_present;
	unsigned int			state;
	Atom 				names[32];
	XkbIndicatorMapRec		maps[32];
} XkbDeviceLedInfoRec,*XkbDeviceLedInfoPtr;

typedef struct _XkbDeviceInfo {
	char *			name;
	Atom			type;
	unsigned short		device_spec;
	int			has_own_state;
	unsigned short		supported;
	unsigned short		unsupported;

	unsigned short		num_btns;
	XkbAction *		btn_acts;

	unsigned short		sz_leds;
	unsigned short		num_leds;
	unsigned short		dflt_kbd_fb;
	unsigned short		dflt_led_fb;
	XkbDeviceLedInfoPtr	leds;
} XkbDeviceInfoRec,*XkbDeviceInfoPtr;





typedef struct _XkbDeviceLedChanges {
	unsigned short		led_class;
	unsigned short		led_id;
	unsigned int		defined;  
	struct _XkbDeviceLedChanges *next;
} XkbDeviceLedChangesRec,*XkbDeviceLedChangesPtr;

typedef struct _XkbDeviceChanges {
	unsigned int		changed;
	unsigned short		first_btn;
	unsigned short		num_btns;
	XkbDeviceLedChangesRec 	leds;
} XkbDeviceChangesRec,*XkbDeviceChangesPtr;

#line 34 "/usr/include/X11/XKBlib.h"

typedef struct _XkbAnyEvent {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	unsigned int 	device;		 
} XkbAnyEvent;

typedef struct _XkbNewKeyboardNotify {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int	 	device;		 
	int	 	old_device;	 
	int	 	min_key_code;	 
	int		max_key_code;	 
	int	 	old_min_key_code; 
	int		old_max_key_code; 
	unsigned int	changed;	 
	char	 	req_major;	 
	char	 	req_minor;	 
} XkbNewKeyboardNotifyEvent;

typedef struct _XkbMapNotifyEvent {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int 		device;		 
	unsigned int 	changed;	 
	unsigned int 	flags;		 
	int 		first_type;	 
	int 		num_types;	 
	KeyCode		min_key_code;
	KeyCode		max_key_code;
	KeyCode		first_key_sym;
	KeyCode		first_key_act;
	KeyCode		first_key_behavior;
	KeyCode		first_key_explicit;
	KeyCode		first_modmap_key;  
	KeyCode		first_vmodmap_key;
	int		num_key_syms;
	int		num_key_acts;
	int		num_key_behaviors;
	int		num_key_explicit;
	int 		num_modmap_keys;
	int 		num_vmodmap_keys;
	unsigned int 	vmods;		 
} XkbMapNotifyEvent;

typedef struct _XkbStateNotifyEvent {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int 		device;		 
	unsigned int 	changed;	 
	int 		group;		 
	int 		base_group;	 
	int 		latched_group;	 
	int 		locked_group;	 
	unsigned int	mods;		 
	unsigned int 	base_mods;	 
	unsigned int	latched_mods;	 
	unsigned int	locked_mods;	 
	int 		compat_state;	 
	unsigned char	grab_mods;	 
	unsigned char	compat_grab_mods; 
	unsigned char	lookup_mods;	 
	unsigned char	compat_lookup_mods;  
	int 		ptr_buttons;	 
	KeyCode		keycode;	 
	char 		event_type;	 
	char 		req_major;	 
	char 		req_minor;	 
} XkbStateNotifyEvent;

typedef struct _XkbControlsNotify {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int 		device;		 
	unsigned int	changed_ctrls;	 
	unsigned int 	enabled_ctrls;	 
	unsigned int	enabled_ctrl_changes; 
	int 		num_groups;	 
	KeyCode		keycode;	 
	char 		event_type;	 
	char 		req_major;	 
	char 		req_minor;	 
} XkbControlsNotifyEvent;

typedef struct _XkbIndicatorNotify {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int 		device;		 
	unsigned int	changed;	 
	unsigned int	state;	 	 
} XkbIndicatorNotifyEvent;

typedef struct _XkbNamesNotify {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int	 	device;		 
	unsigned int 	changed;	 
	int	 	first_type;	 
	int	 	num_types;	 
	int	 	first_lvl;	 
	int	 	num_lvls;	 
	int	 	num_aliases;	 
	int	 	num_radio_groups; 
	unsigned int 	changed_vmods;	 
	unsigned int 	changed_groups;	 
	unsigned int 	changed_indicators; 
	int		first_key;	 
	int		num_keys;	 
} XkbNamesNotifyEvent;

typedef struct _XkbCompatMapNotify {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int	 	device;		 
	unsigned int 	changed_groups;  
	int	 	first_si;	 
	int	 	num_si;		 
	int	 	num_total_si;	 
} XkbCompatMapNotifyEvent;

typedef struct _XkbBellNotify {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int	 	device;		 
	int	 	percent;	 
	int	 	pitch;		 
	int	 	duration;	 
	int	 	bell_class;	 
	int	 	bell_id;	 
	Atom 		name;		 
	Window 		window;		 
	int		event_only;	 
} XkbBellNotifyEvent;

typedef struct _XkbActionMessage {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int	 	device;		 
	KeyCode		keycode;	 
	int 		press;		 
	int 		key_event_follows; 
	int		group;		 
	unsigned int	mods;		 
	char 		message[6+1]; 
					 
} XkbActionMessageEvent;

typedef struct _XkbAccessXNotify {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int	 	device;		 
	int	 	detail;		 
	int	 	keycode;	 
	int	 	sk_delay;	 
	int		debounce_delay;	 
} XkbAccessXNotifyEvent;

typedef struct _XkbExtensionDeviceNotify {
	int 		type;		 
	unsigned long 	serial;		 
	int 		send_event;	 
	Display *	display;	 
	Time 		time;		 
	int 		xkb_type;	 
	int	 	device;		 
	unsigned int	reason;		 	
	unsigned int	supported;	 	
	unsigned int	unsupported;	 
					 
	int	 	first_btn;	 
	int	 	num_btns;	 
	unsigned int	leds_defined;    
	unsigned int	led_state;	 
	int		led_class;	 
	int		led_id;   	 
} XkbExtensionDeviceNotifyEvent;

typedef union _XkbEvent {
	int				type;
	XkbAnyEvent			any;
	XkbNewKeyboardNotifyEvent	new_kbd;
	XkbMapNotifyEvent		map;
	XkbStateNotifyEvent		state;
	XkbControlsNotifyEvent		ctrls;
	XkbIndicatorNotifyEvent 	indicators;
	XkbNamesNotifyEvent		names;
	XkbCompatMapNotifyEvent		compat;
	XkbBellNotifyEvent		bell;
	XkbActionMessageEvent		message;
	XkbAccessXNotifyEvent		accessx;
	XkbExtensionDeviceNotifyEvent 	device;
	XEvent				core;
} XkbEvent;

typedef struct	_XkbKbdDpyState	XkbKbdDpyStateRec,*XkbKbdDpyStatePtr;

	 






	 
#line 291 "/usr/include/X11/XKBlib.h"




extern "C" {

extern	int	XkbIgnoreExtension(
	int			 
);

extern	Display *XkbOpenDisplay(
	char *			 ,
	int *			 ,
	int *			 ,
	int *			 ,
	int *			 ,
	int *			 
);

extern	int	XkbQueryExtension(
	Display *		 ,
	int *			 ,
	int *			 ,
	int *			 ,
	int *			 ,
	int *			 
);

extern	int	XkbUseExtension(
	Display *		 ,
	int *			 ,
	int *			 
);

extern	int	XkbLibraryVersion(
	int *			 ,
	int *			 
);

extern	unsigned int	XkbSetXlibControls(
	Display*		 ,
	unsigned int		 ,
	unsigned int		 
);

extern	unsigned int	XkbGetXlibControls(
	Display*		 
);

extern	unsigned int	XkbXlibControlsImplemented(void);

typedef	Atom	(*XkbInternAtomFunc)(
	Display *		 ,
	const char *		 ,
	int			 
);

typedef char *	(*XkbGetAtomNameFunc)(
	Display *		 ,
	Atom			 
);

extern void		XkbSetAtomFuncs(
	XkbInternAtomFunc	 ,
	XkbGetAtomNameFunc	 
);

extern	KeySym XkbKeycodeToKeysym(
		Display *	 ,

		 unsigned int 	 ,



		 int 		 ,
		 int		 
);

extern	unsigned int	XkbKeysymToModifiers(
    Display *			 ,
    KeySym 			 
);

extern	int		XkbLookupKeySym(
    Display *			 ,
    KeyCode 			 ,
    unsigned int 		 ,
    unsigned int *		 ,
    KeySym *			 
);

extern	int		XkbLookupKeyBinding(
    Display *			 ,
    KeySym 			 ,
    unsigned int 		 ,
    char *			 ,
    int 			 ,
    int * 			 
);

extern	int		XkbTranslateKeyCode(
    XkbDescPtr			 ,
    KeyCode 			 ,
    unsigned int 		 ,
    unsigned int *		 ,
    KeySym *			 
);

extern	int		XkbTranslateKeySym(
    Display *			 ,
    register KeySym *		 ,
    unsigned int 		 ,
    char *			 ,
    int 			 ,
    int *			 
);

extern	int	XkbSetAutoRepeatRate(
	Display *		 ,
	unsigned int		 ,
	unsigned int		 ,
	unsigned int		 
);

extern	int	XkbGetAutoRepeatRate(
	Display *		 ,
	unsigned int		 ,
	unsigned int *		 ,
	unsigned int *		 
);

extern	int	XkbChangeEnabledControls(
	Display *		 ,
	unsigned int		 ,
	unsigned int		 ,
	unsigned int		 
);

extern	int	XkbDeviceBell(
	Display *		 ,
	Window			 ,
	int			 ,
	int			 ,
	int			 ,
	int			 ,
	Atom			 
);

extern	int	XkbForceDeviceBell(
	Display *		 ,
	int			 ,
	int			 ,
	int			 ,
	int			 
);

extern	int	XkbDeviceBellEvent(
	Display *		 ,
	Window			 ,
	int			 ,
	int			 ,
	int			 ,
	int			 ,
	Atom			 
);

extern	int	XkbBell(
	Display *		 ,
	Window			 ,
	int			 ,
	Atom			 
);

extern	int	XkbForceBell(
	Display *		 ,
	int			 
);

extern	int	XkbBellEvent(
	Display *		 ,
	Window			 ,
	int			 ,
	Atom			 
);

extern	int	XkbSelectEvents(
	Display *		 ,
	unsigned int		 ,
	unsigned int 		 ,
	unsigned int 		 
);

extern	int	XkbSelectEventDetails(
	Display *		 ,
	unsigned int 		 ,
	unsigned int 		 ,
	unsigned long 		 ,
	unsigned long 		 
);

extern	void	XkbNoteMapChanges(
    XkbMapChangesPtr		 ,
    XkbMapNotifyEvent	*	 ,
    unsigned int	 	 
);

extern	void	XkbNoteNameChanges(
    XkbNameChangesPtr		 ,
    XkbNamesNotifyEvent	*	 ,
    unsigned int	 	 
);

extern	int	XkbGetIndicatorState(
	Display *		 ,
	unsigned int		 ,
	unsigned int *		 
);

extern	int	XkbGetDeviceIndicatorState(
	Display *		 ,
	unsigned int		 ,
	unsigned int		 ,
	unsigned int		 ,
	unsigned int *		 
);

extern	int	 XkbGetIndicatorMap(
	Display *		 ,
	unsigned long		 ,
	XkbDescPtr		 
);

extern	int	 XkbSetIndicatorMap(
	Display *		 ,
	unsigned long 		 ,
	XkbDescPtr		 
);

#line 537 "/usr/include/X11/XKBlib.h"

extern	int	XkbGetNamedIndicator(
	Display *		 ,
	Atom			 ,
	int *			 ,
	int *			 ,
	XkbIndicatorMapPtr	 ,
	int *			 
);

extern	int	XkbGetNamedDeviceIndicator(
	Display *		 ,
	unsigned int		 ,
	unsigned int		 ,
	unsigned int		 ,
	Atom			 ,
	int *			 ,
	int *			 ,
	XkbIndicatorMapPtr	 ,
	int *			 
);

extern	int	XkbSetNamedIndicator(
	Display *		 ,
	Atom			 ,
	int			 ,
	int 			 ,
	int			 ,
	XkbIndicatorMapPtr	 
);

extern	int	XkbSetNamedDeviceIndicator(
	Display *		 ,
	unsigned int		 ,
	unsigned int		 ,
	unsigned int		 ,
	Atom			 ,
	int			 ,
	int 			 ,
	int			 ,
	XkbIndicatorMapPtr	 
);

extern	int	XkbLockModifiers(
	Display *		 ,
	unsigned int 		 ,
	unsigned int 		 ,
	unsigned int 		 
);

extern	int	XkbLatchModifiers(
	Display *		 ,
	unsigned int 		 ,
	unsigned int 		 ,
	unsigned int 		 
);

extern	int	XkbLockGroup(
	Display *		 ,
	unsigned int 		 ,
	unsigned int 		 
);

extern	int	XkbLatchGroup(
	Display *		 ,
	unsigned int 		 ,
	unsigned int 		 
);

extern	int	XkbSetServerInternalMods(
	Display *		 ,
	unsigned int 		 ,
	unsigned int 		 ,
	unsigned int 		 ,
	unsigned int		 ,
	unsigned int		 
);

extern	int	XkbSetIgnoreLockMods(
	Display *		 ,
	unsigned int 		 ,
	unsigned int 		 ,
	unsigned int 		 ,
	unsigned int		 ,
	unsigned int		 
);


extern	int	XkbVirtualModsToReal(
	XkbDescPtr		 ,
	unsigned int		 ,
	unsigned int *		 
);

extern	int	XkbComputeEffectiveMap(
	XkbDescPtr 		 ,
	XkbKeyTypePtr		 ,
	unsigned char *		 
);

extern	int XkbInitCanonicalKeyTypes(
    XkbDescPtr			 ,
    unsigned int		 ,
    int				 
);

extern	XkbDescPtr XkbAllocKeyboard(
	void
);

extern	void	XkbFreeKeyboard(
	XkbDescPtr		 ,
	unsigned int		 ,
	int			 
);

extern	int XkbAllocClientMap(
	XkbDescPtr		 ,
	unsigned int		 ,
	unsigned int		 
);

extern	int XkbAllocServerMap(
	XkbDescPtr		 ,
	unsigned int		 ,
	unsigned int		 
);

extern	void	XkbFreeClientMap(
    XkbDescPtr			 ,
    unsigned int		 ,
    int			 
);

extern	void	XkbFreeServerMap(
    XkbDescPtr			 ,
    unsigned int		 ,
    int			 
);

extern	XkbKeyTypePtr	XkbAddKeyType(
    XkbDescPtr			 ,
    Atom			 ,
    int				 ,
    int			 ,
    int				 
);

extern	int XkbAllocIndicatorMaps(
	XkbDescPtr		 
);

extern	void XkbFreeIndicatorMaps(
    XkbDescPtr			 
);

extern	XkbDescPtr XkbGetMap(
	Display *		 ,
	unsigned int 		 ,
	unsigned int 		 
);

extern	int	XkbGetUpdatedMap(
	Display *		 ,
	unsigned int 		 ,
	XkbDescPtr		 
);

extern	int	XkbGetMapChanges(
    Display *			 ,
    XkbDescPtr			 ,
    XkbMapChangesPtr		 
);


extern	int	XkbRefreshKeyboardMapping(
    XkbMapNotifyEvent *		 
);

extern	int	XkbGetKeyTypes(
    Display *			 ,
    unsigned int		 ,
    unsigned int 		 ,
    XkbDescPtr			 
);

extern	int	XkbGetKeySyms(
    Display *			 ,
    unsigned int		 ,
    unsigned int		 ,
    XkbDescPtr			 
);

extern	int	XkbGetKeyActions(
    Display *			 ,
    unsigned int 		 ,
    unsigned int 		 ,
    XkbDescPtr			 
);

extern	int	XkbGetKeyBehaviors(
	Display *		 ,
	unsigned int 		 ,
	unsigned int		 ,
	XkbDescPtr		 
);

extern	int	XkbGetVirtualMods(
	Display *		 ,
	unsigned int 		 ,
	XkbDescPtr		 
);

extern	int	XkbGetKeyExplicitComponents(
	Display *		 ,
	unsigned int 		 ,
	unsigned int		 ,
	XkbDescPtr		 
);

extern	int	XkbGetKeyModifierMap(
	Display *		 ,
	unsigned int 		 ,
	unsigned int		 ,
	XkbDescPtr		 
);

extern	int	XkbGetKeyVirtualModMap(
	Display *		 ,
	unsigned int		 ,
	unsigned int		 ,
	XkbDescPtr		 
);

extern	int	XkbAllocControls(
	XkbDescPtr		 ,
	unsigned int		 
);

extern	void	XkbFreeControls(
	XkbDescPtr		 ,
	unsigned int		 ,
	int			 
);

extern	int	XkbGetControls(
	Display *		 ,
	unsigned long		 ,
	XkbDescPtr		 
);

extern	int	XkbSetControls(
	Display *		 ,
	unsigned long		 ,
	XkbDescPtr		 
);

extern	void	XkbNoteControlsChanges(
    XkbControlsChangesPtr	 ,
    XkbControlsNotifyEvent *	 ,
    unsigned int	 	 
);




extern	int	XkbAllocCompatMap(
    XkbDescPtr			 ,
    unsigned int		 ,
    unsigned int		 
);

extern	void	XkbFreeCompatMap(
    XkbDescPtr			 ,
    unsigned int		 ,
    int			 
);

extern int XkbGetCompatMap(
	Display *		 ,
	unsigned int 		 ,
	XkbDescPtr 		 
);

extern int XkbSetCompatMap(
	Display *		 ,
	unsigned int 		 ,
	XkbDescPtr 		 ,
	int			 
);

extern	XkbSymInterpretPtr XkbAddSymInterpret(
	XkbDescPtr		 ,
	XkbSymInterpretPtr	 ,
	int			 ,
	XkbChangesPtr		 
);

extern	int XkbAllocNames(
	XkbDescPtr		 ,
	unsigned int		 ,
	int			 ,
	int			 
);

extern	int	XkbGetNames(
	Display *		 ,
	unsigned int		 ,
	XkbDescPtr		 
);

extern	int	XkbSetNames(
	Display *		 ,
	unsigned int		 ,
	unsigned int		 ,
	unsigned int		 ,
	XkbDescPtr		 
);

extern	int	XkbChangeNames(
	Display *		 ,
	XkbDescPtr		 ,
	XkbNameChangesPtr	 
);

extern	void XkbFreeNames(
	XkbDescPtr		 ,
	unsigned int		 ,
	int			 
);


extern	int	XkbGetState(
	Display *		 ,
	unsigned int 		 ,
	XkbStatePtr		 
);

extern	int	XkbSetMap(
	Display *		 ,
	unsigned int		 ,
	XkbDescPtr		 
);

extern	int	XkbChangeMap(
	Display*		 ,
	XkbDescPtr		 ,
	XkbMapChangesPtr	 
);

extern	int	XkbSetDetectableAutoRepeat(
	Display *		 ,
	int			 ,
	int *			 
);

extern	int	XkbGetDetectableAutoRepeat(
	Display *		 ,
	int *			 
);

extern	int	XkbSetAutoResetControls(
    Display *			 ,
    unsigned int 		 ,
    unsigned int *		 ,
    unsigned int *		 
);

extern	int	XkbGetAutoResetControls(
    Display *			 ,
    unsigned int *		 ,
    unsigned int *		 
);

extern	int	XkbSetPerClientControls(
    Display *			 ,
    unsigned int		 ,
    unsigned int *		 
);

extern	int	XkbGetPerClientControls(
    Display *			 ,
    unsigned int *		 
);

extern int XkbCopyKeyType(
    XkbKeyTypePtr	 ,
    XkbKeyTypePtr	 
);

extern int XkbCopyKeyTypes(
    XkbKeyTypePtr	 ,
    XkbKeyTypePtr	 ,
    int			 
);

extern	int	XkbResizeKeyType(
    XkbDescPtr		 ,
    int			 ,
    int			 ,
    int		 ,
    int			 
);

extern	KeySym *XkbResizeKeySyms(
	XkbDescPtr		 ,
	int 			 ,
	int 			 
);

extern	XkbAction *XkbResizeKeyActions(
	XkbDescPtr		 ,
	int 			 ,
	int 			 
);

extern	int XkbChangeTypesOfKey(
	XkbDescPtr		 ,
	int 			 ,
	int			 ,
	unsigned int		 ,
	int *			 ,
	XkbMapChangesPtr	 
);

extern  int   XkbChangeKeycodeRange(
	XkbDescPtr		 ,
	int			 ,
	int			 ,
	XkbChangesPtr		 
);

 

extern	XkbComponentListPtr	XkbListComponents(
	Display *		 ,
	unsigned int		 ,
	XkbComponentNamesPtr	 ,
	int *			 
);

extern	void XkbFreeComponentList(
	XkbComponentListPtr	 
);

extern	XkbDescPtr XkbGetKeyboard(
	Display *		 ,
	unsigned int 		 ,
	unsigned int 		 
);

extern XkbDescPtr XkbGetKeyboardByName(
    Display *			 ,
    unsigned int		 ,
    XkbComponentNamesPtr	 ,
    unsigned int 		 ,
    unsigned int 		 ,
    int			 
);

 

extern	int	XkbKeyTypesForCoreSymbols(	 
    XkbDescPtr	 ,			 
    int		 ,		 
    KeySym *	 ,		 
    unsigned int	 ,	 
    int *	 ,		 
    KeySym * 	 		 
);

extern	int	XkbApplyCompatMapToKey(	 
    XkbDescPtr		 ,		 
    KeyCode		 ,		 
    XkbChangesPtr	 		 
);

extern	int	XkbUpdateMapFromCore(  
    XkbDescPtr		 ,		 
    KeyCode		 ,	 
    int			 , 	 
    int			 ,	 
    KeySym *		 ,	 
    XkbChangesPtr	 		 
);

 

extern	XkbDeviceLedInfoPtr	XkbAddDeviceLedInfo(
	XkbDeviceInfoPtr	 ,
	unsigned int		 ,
	unsigned int		 
);

extern	int			XkbResizeDeviceButtonActions(
	XkbDeviceInfoPtr	 ,
	unsigned int		 
);

extern	XkbDeviceInfoPtr	XkbAllocDeviceInfo(
	unsigned int		 ,
	unsigned int		 ,
	unsigned int		 
);

extern	void XkbFreeDeviceInfo(
	XkbDeviceInfoPtr	 ,
	unsigned int		 ,
	int			 
);

extern	void	XkbNoteDeviceChanges(
    XkbDeviceChangesPtr			 ,
    XkbExtensionDeviceNotifyEvent *	 ,
    unsigned int	 		 
);

extern	XkbDeviceInfoPtr XkbGetDeviceInfo(
	Display *		 ,
	unsigned int 		 ,
	unsigned int		 ,
	unsigned int		 ,
	unsigned int		 
);

extern	int	XkbGetDeviceInfoChanges(
	Display *		 ,
	XkbDeviceInfoPtr	 ,
	XkbDeviceChangesPtr 	 
);

extern	int	XkbGetDeviceButtonActions(
	Display *		 ,
	XkbDeviceInfoPtr	 ,
	int			 ,
	unsigned int		 ,
	unsigned int		 
);

extern	int	XkbGetDeviceLedInfo(
	Display *		 ,
	XkbDeviceInfoPtr	 ,
	unsigned int		 ,
	unsigned int		 ,
	unsigned int		 
);

extern	int	XkbSetDeviceInfo(
	Display *		 ,
	unsigned int		 ,
	XkbDeviceInfoPtr	 
);

extern	int	XkbChangeDeviceInfo(
	Display*		 ,
	XkbDeviceInfoPtr	 ,
	XkbDeviceChangesPtr	 
);

extern  int XkbSetDeviceLedInfo(
	Display *		 ,
	XkbDeviceInfoPtr	 ,
	unsigned int 		 ,
	unsigned int		 ,
	unsigned int		 
);

extern	int XkbSetDeviceButtonActions(
	Display *		 ,
	XkbDeviceInfoPtr	 ,
	unsigned int		 ,
	unsigned int		 
);

 

extern	char	XkbToControl(
	char		 
);

 

extern	int XkbSetDebuggingFlags(
    Display *		 ,
    unsigned int	 ,
    unsigned int	 ,
    char *		 ,
    unsigned int	 ,
    unsigned int	 ,
    unsigned int *	 ,
    unsigned int *	 
);

extern	int XkbApplyVirtualModChanges(
   XkbDescPtr		 ,
   unsigned int		 ,
   XkbChangesPtr	 
);

extern int XkbUpdateActionVirtualMods(
	XkbDescPtr		 ,
	XkbAction *		 ,
	unsigned int		 
);

extern void XkbUpdateKeyTypeVirtualMods(
	XkbDescPtr		 ,
	XkbKeyTypePtr		 ,
	unsigned int		 ,
	XkbChangesPtr		 
);

}

#line 144 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"



#line 153 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"


#line 175 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"









 









extern "C" int XRegisterIMInstantiateCallback(
    Display*,
    struct _XrmHashBucketRec*,
    char*,
    char*,
    XIMProc, 
    XPointer
);

extern "C" int XUnregisterIMInstantiateCallback(
    Display*,
    struct _XrmHashBucketRec*,
    char*,
    char*,
    XIMProc, 
    XPointer
);

extern "C" char *XSetIMValues(XIM  , ...);



#line 1 "/usr/include/fontconfig/fontconfig.h"






















 






typedef unsigned char	FcChar8;
typedef unsigned short	FcChar16;
typedef unsigned int	FcChar32;
typedef int		FcBool;





 















 






#line 91 "/usr/include/fontconfig/fontconfig.h"




 




#line 114 "/usr/include/fontconfig/fontconfig.h"





#line 128 "/usr/include/fontconfig/fontconfig.h"





 
#line 140 "/usr/include/fontconfig/fontconfig.h"

typedef enum _FcType {
    FcTypeVoid, 
    FcTypeInteger, 
    FcTypeDouble, 
    FcTypeString, 
    FcTypeBool,
    FcTypeMatrix,
    FcTypeCharSet,
    FcTypeFTFace,
    FcTypeLangSet
} FcType;

typedef struct _FcMatrix {
    double xx, xy, yx, yy;
} FcMatrix;







 

typedef struct _FcCharSet FcCharSet;

typedef struct _FcObjectType {
    const char	*object;
    FcType	type;
} FcObjectType;

typedef struct _FcConstant {
    const FcChar8  *name;
    const char	*object;
    int		value;
} FcConstant;

typedef enum _FcResult {
    FcResultMatch, FcResultNoMatch, FcResultTypeMismatch, FcResultNoId
} FcResult;

typedef struct _FcPattern   FcPattern;

typedef struct _FcLangSet   FcLangSet;

typedef struct _FcValue {
    FcType	type;
    union {
	const FcChar8	*s;
	int		i;
	FcBool		b;
	double		d;
	const FcMatrix	*m;
	const FcCharSet	*c;
	void		*f;
	const FcPattern	*p;
	const FcLangSet	*l;
    } u;
} FcValue;

typedef struct _FcFontSet {
    int		nfont;
    int		sfont;
    FcPattern	**fonts;
} FcFontSet;

typedef struct _FcObjectSet {
    int		nobject;
    int		sobject;
    const char	**objects;
} FcObjectSet;
    
typedef enum _FcMatchKind {
    FcMatchPattern, FcMatchFont
} FcMatchKind;

typedef enum _FcLangResult {
    FcLangEqual, FcLangDifferentCountry, FcLangDifferentLang
} FcLangResult;

typedef enum _FcSetName {
    FcSetSystem = 0,
    FcSetApplication = 1
} FcSetName;

typedef struct _FcAtomic FcAtomic;

#line 235 "/usr/include/fontconfig/fontconfig.h"

typedef enum { FcEndianBig, FcEndianLittle } FcEndian;

typedef struct _FcConfig    FcConfig;

typedef struct _FcGlobalCache	FcFileCache;

typedef struct _FcBlanks    FcBlanks;

typedef struct _FcStrList   FcStrList;

typedef struct _FcStrSet    FcStrSet;

extern "C" {

FcBool
FcDirCacheValid (const FcChar8 *cache_file);

 
FcBlanks *
FcBlanksCreate (void);

void
FcBlanksDestroy (FcBlanks *b);

FcBool
FcBlanksAdd (FcBlanks *b, FcChar32 ucs4);

FcBool
FcBlanksIsMember (FcBlanks *b, FcChar32 ucs4);

 
FcChar8 *
FcConfigHome (void);

FcBool
FcConfigEnableHome (FcBool enable);

FcChar8 *
FcConfigFilename (const FcChar8 *url);
    
FcConfig *
FcConfigCreate (void);

void
FcConfigDestroy (FcConfig *config);

FcBool
FcConfigSetCurrent (FcConfig *config);

FcConfig *
FcConfigGetCurrent (void);

FcBool
FcConfigUptoDate (FcConfig *config);
    
FcBool
FcConfigBuildFonts (FcConfig *config);

FcStrList *
FcConfigGetFontDirs (FcConfig   *config);

FcStrList *
FcConfigGetConfigDirs (FcConfig   *config);

FcStrList *
FcConfigGetConfigFiles (FcConfig    *config);

FcChar8 *
FcConfigGetCache (FcConfig  *config);

FcBlanks *
FcConfigGetBlanks (FcConfig *config);

int
FcConfigGetRescanInverval (FcConfig *config);

FcBool
FcConfigSetRescanInverval (FcConfig *config, int rescanInterval);

FcFontSet *
FcConfigGetFonts (FcConfig	*config,
		  FcSetName	set);

FcBool
FcConfigAppFontAddFile (FcConfig    *config,
			const FcChar8  *file);

FcBool
FcConfigAppFontAddDir (FcConfig	    *config,
		       const FcChar8   *dir);

void
FcConfigAppFontClear (FcConfig	    *config);

FcBool
FcConfigSubstituteWithPat (FcConfig	*config,
			   FcPattern	*p,
			   FcPattern	*p_pat,
			   FcMatchKind	kind);

FcBool
FcConfigSubstitute (FcConfig	*config,
		    FcPattern	*p,
		    FcMatchKind	kind);

 
FcCharSet *
FcCharSetCreate (void);

void
FcCharSetDestroy (FcCharSet *fcs);

FcBool
FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4);

FcCharSet *
FcCharSetCopy (FcCharSet *src);

FcBool
FcCharSetEqual (const FcCharSet *a, const FcCharSet *b);

FcCharSet *
FcCharSetIntersect (const FcCharSet *a, const FcCharSet *b);

FcCharSet *
FcCharSetUnion (const FcCharSet *a, const FcCharSet *b);

FcCharSet *
FcCharSetSubtract (const FcCharSet *a, const FcCharSet *b);

FcBool
FcCharSetHasChar (const FcCharSet *fcs, FcChar32 ucs4);

FcChar32
FcCharSetCount (const FcCharSet *a);

FcChar32
FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b);

FcChar32
FcCharSetSubtractCount (const FcCharSet *a, const FcCharSet *b);

FcBool
FcCharSetIsSubset (const FcCharSet *a, const FcCharSet *b);




FcChar32
FcCharSetFirstPage (const FcCharSet *a, 
		    FcChar32	    map[(256/32)],
		    FcChar32	    *next);

FcChar32
FcCharSetNextPage (const FcCharSet  *a, 
		   FcChar32	    map[(256/32)],
		   FcChar32	    *next);


 
void
FcValuePrint (const FcValue v);

void
FcPatternPrint (const FcPattern *p);

void
FcFontSetPrint (const FcFontSet *s);

 
void
FcDefaultSubstitute (FcPattern *pattern);

 
FcBool
FcFileScan (FcFontSet	    *set,
	    FcStrSet	    *dirs,
	    FcFileCache	    *cache,
	    FcBlanks	    *blanks,
	    const FcChar8   *file,
	    FcBool	    force);

FcBool
FcDirScan (FcFontSet	    *set,
	   FcStrSet	    *dirs,
	   FcFileCache	    *cache,
	   FcBlanks	    *blanks,
	   const FcChar8    *dir,
	   FcBool	    force);

FcBool
FcDirSave (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);

 
FcPattern *
FcFreeTypeQuery (const FcChar8 *file, int id, FcBlanks *blanks, int *count);

 

FcFontSet *
FcFontSetCreate (void);

void
FcFontSetDestroy (FcFontSet *s);

FcBool
FcFontSetAdd (FcFontSet *s, FcPattern *font);

 
FcConfig *
FcInitLoadConfig (void);

FcConfig *
FcInitLoadConfigAndFonts (void);

FcBool
FcInit (void);

int
FcGetVersion (void);

FcBool
FcInitReinitialize (void);

FcBool
FcInitBringUptoDate (void);

 
FcLangSet *
FcLangSetCreate (void);

void
FcLangSetDestroy (FcLangSet *ls);

FcLangSet *
FcLangSetCopy (const FcLangSet *ls);

FcBool
FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang);

FcLangResult
FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang);

FcLangResult
FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb);

FcBool
FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb);

FcBool
FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb);

FcChar32
FcLangSetHash (const FcLangSet *ls);

 
FcObjectSet *
FcObjectSetCreate (void);

FcBool
FcObjectSetAdd (FcObjectSet *os, const char *object);

void
FcObjectSetDestroy (FcObjectSet *os);

FcObjectSet *
FcObjectSetVaBuild (const char *first, va_list va);

FcObjectSet *
FcObjectSetBuild (const char *first, ...);

FcFontSet *
FcFontSetList (FcConfig	    *config,
	       FcFontSet    **sets,
	       int	    nsets,
	       FcPattern    *p,
	       FcObjectSet  *os);

FcFontSet *
FcFontList (FcConfig	*config,
	    FcPattern	*p,
	    FcObjectSet *os);

 

FcAtomic *
FcAtomicCreate (const FcChar8   *file);

FcBool
FcAtomicLock (FcAtomic *atomic);

FcChar8 *
FcAtomicNewFile (FcAtomic *atomic);

FcChar8 *
FcAtomicOrigFile (FcAtomic *atomic);

FcBool
FcAtomicReplaceOrig (FcAtomic *atomic);

void
FcAtomicDeleteNew (FcAtomic *atomic);

void
FcAtomicUnlock (FcAtomic *atomic);

void
FcAtomicDestroy (FcAtomic *atomic);

 
FcPattern *
FcFontSetMatch (FcConfig    *config,
		FcFontSet   **sets,
		int	    nsets,
		FcPattern   *p,
		FcResult    *result);

FcPattern *
FcFontMatch (FcConfig	*config,
	     FcPattern	*p, 
	     FcResult	*result);

FcPattern *
FcFontRenderPrepare (FcConfig	    *config,
		     FcPattern	    *pat,
		     FcPattern	    *font);

FcFontSet *
FcFontSetSort (FcConfig	    *config,
	       FcFontSet    **sets,
	       int	    nsets,
	       FcPattern    *p,
	       FcBool	    trim,
	       FcCharSet    **csp,
	       FcResult	    *result);

FcFontSet *
FcFontSort (FcConfig	 *config,
	    FcPattern    *p,
	    FcBool	 trim,
	    FcCharSet    **csp,
	    FcResult	 *result);

void
FcFontSetSortDestroy (FcFontSet *fs);

 
FcMatrix *
FcMatrixCopy (const FcMatrix *mat);

FcBool
FcMatrixEqual (const FcMatrix *mat1, const FcMatrix *mat2);

void
FcMatrixMultiply (FcMatrix *result, const FcMatrix *a, const FcMatrix *b);

void
FcMatrixRotate (FcMatrix *m, double c, double s);

void
FcMatrixScale (FcMatrix *m, double sx, double sy);

void
FcMatrixShear (FcMatrix *m, double sh, double sv);

 

FcBool
FcNameRegisterObjectTypes (const FcObjectType *types, int ntype);

FcBool
FcNameUnregisterObjectTypes (const FcObjectType *types, int ntype);
    
const FcObjectType *
FcNameGetObjectType (const char *object);

FcBool
FcNameRegisterConstants (const FcConstant *consts, int nconsts);

FcBool
FcNameUnregisterConstants (const FcConstant *consts, int nconsts);
    
const FcConstant *
FcNameGetConstant (FcChar8 *string);

FcBool
FcNameConstant (FcChar8 *string, int *result);

FcPattern *
FcNameParse (const FcChar8 *name);

FcChar8 *
FcNameUnparse (FcPattern *pat);

 
FcPattern *
FcPatternCreate (void);

FcPattern *
FcPatternDuplicate (const FcPattern *p);

void
FcPatternReference (FcPattern *p);

void
FcValueDestroy (FcValue v);

FcBool
FcValueEqual (FcValue va, FcValue vb);

FcValue
FcValueSave (FcValue v);

void
FcPatternDestroy (FcPattern *p);

FcBool
FcPatternEqual (const FcPattern *pa, const FcPattern *pb);

FcBool
FcPatternEqualSubset (const FcPattern *pa, const FcPattern *pb, const FcObjectSet *os);

FcChar32
FcPatternHash (const FcPattern *p);

FcBool
FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append);
    
FcBool
FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append);
    
FcResult
FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v);
    
FcBool
FcPatternDel (FcPattern *p, const char *object);

FcBool
FcPatternAddInteger (FcPattern *p, const char *object, int i);

FcBool
FcPatternAddDouble (FcPattern *p, const char *object, double d);

FcBool
FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s);

FcBool
FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s);

FcBool
FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c);

FcBool
FcPatternAddBool (FcPattern *p, const char *object, FcBool b);

FcBool
FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls);

FcResult
FcPatternGetInteger (const FcPattern *p, const char *object, int n, int *i);

FcResult
FcPatternGetDouble (const FcPattern *p, const char *object, int n, double *d);

FcResult
FcPatternGetString (const FcPattern *p, const char *object, int n, FcChar8 ** s);

FcResult
FcPatternGetMatrix (const FcPattern *p, const char *object, int n, FcMatrix **s);

FcResult
FcPatternGetCharSet (const FcPattern *p, const char *object, int n, FcCharSet **c);

FcResult
FcPatternGetBool (const FcPattern *p, const char *object, int n, FcBool *b);

FcResult
FcPatternGetLangSet (const FcPattern *p, const char *object, int n, FcLangSet **ls);

FcPattern *
FcPatternVaBuild (FcPattern *orig, va_list va);
    
FcPattern *
FcPatternBuild (FcPattern *orig, ...);

 

FcChar8 *
FcStrCopy (const FcChar8 *s);

FcChar8 *
FcStrCopyFilename (const FcChar8 *s);
    




int
FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);

int
FcStrCmp (const FcChar8 *s1, const FcChar8 *s2);

int
FcUtf8ToUcs4 (const FcChar8 *src_orig,
	      FcChar32	    *dst,
	      int	    len);

FcBool
FcUtf8Len (const FcChar8    *string,
	   int		    len,
	   int		    *nchar,
	   int		    *wchar);



int
FcUcs4ToUtf8 (FcChar32	ucs4,
	      FcChar8	dest[6]);

int
FcUtf16ToUcs4 (const FcChar8	*src_orig,
	       FcEndian		endian,
	       FcChar32		*dst,
	       int		len);	     

FcBool
FcUtf16Len (const FcChar8   *string,
	    FcEndian	    endian,
	    int		    len,	     
	    int		    *nchar,
	    int		    *wchar);

FcChar8 *
FcStrDirname (const FcChar8 *file);

FcChar8 *
FcStrBasename (const FcChar8 *file);

FcStrSet *
FcStrSetCreate (void);

FcBool
FcStrSetMember (FcStrSet *set, const FcChar8 *s);

FcBool
FcStrSetEqual (FcStrSet *sa, FcStrSet *sb);

FcBool
FcStrSetAdd (FcStrSet *set, const FcChar8 *s);

FcBool
FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s);

FcBool
FcStrSetDel (FcStrSet *set, const FcChar8 *s);

void
FcStrSetDestroy (FcStrSet *set);

FcStrList *
FcStrListCreate (FcStrSet *set);

FcChar8 *
FcStrListNext (FcStrList *list);

void
FcStrListDone (FcStrList *list);

 
FcBool
FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain);

}

#line 218 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"




#line 229 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"


#line 1 "/usr/include/X11/Xlocale.h"
 


























 
 







#line 60 "/usr/include/X11/Xlocale.h"

#line 233 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"







class QWidget;


struct QX11InfoData {
    uint ref;
    int screen;
    int dpiX;
    int dpiY;
    int depth;
    int cells;
    Colormap colormap;
    Visual *visual;
    bool defaultColormap;
    bool defaultVisual;
    int subpixel;
};

class QDrag;
struct QXdndDropTransaction
{
    Time timestamp;
    Window target;
    Window proxy_target;
    QWidget *embedding_widget;
    QDrag *object;
};

struct QX11Data;
extern QX11Data *qt_x11Data;

struct QX11Data
{
    Window findClientWindow(Window, Atom, bool);

    
    bool clipboardWaitForEvent(Window win, int type, XEvent *event, int timeout);
    bool clipboardReadProperty(Window win, Atom property, bool deleteProperty,
                            QByteArray *buffer, int *size, Atom *type, int *format, bool nullterm);
    QByteArray clipboardReadIncrementalProperty(Window win, Atom property, int nbytes, bool nullterm);

    
    bool dndEnable(QWidget* w, bool on);
    static void xdndSetup();
    void xdndHandleEnter(QWidget *, const XEvent *, bool);
    void xdndHandlePosition(QWidget *, const XEvent *, bool);
    void xdndHandleStatus(QWidget *, const XEvent *, bool);
    void xdndHandleLeave(QWidget *, const XEvent *, bool);
    void xdndHandleDrop(QWidget *, const XEvent *, bool);
    void xdndHandleFinished(QWidget *, const XEvent *, bool);
    void xdndHandleSelectionRequest(const XSelectionRequestEvent *);
    static bool xdndHandleBadwindow();
    QByteArray xdndAtomToString(Atom a);
    Atom xdndStringToAtom(const char *);

    QList<QXdndDropTransaction> dndDropTransactions;

    
    void motifdndHandle(QWidget *, const XEvent *, bool);
    void motifdndEnable(QWidget *, bool);
    QByteArray motifdndObtainData(const char *format);
    QByteArray motifdndFormat(int n);
    bool motifdnd_active;

    Display *display;
    char *displayName;
    bool foreignDisplay;
    
    enum {
        FM_Unknown = -1,
        FM_Other = 0,
        FM_PointerRoot = 1
    };
    int focus_model;

    
    bool use_xrandr;
    int xrandr_major;
    int xrandr_eventbase;
    int xrandr_errorbase;

    
    bool use_xrender;
    int xrender_major;
    int xrender_eventbase;
    int xrender_errorbase;

    
    bool use_xinput;
    int xinput_major;
    int xinput_eventbase;
    int xinput_errorbase;

    QList<QWidget *> deferred_map;
    struct ScrollInProgress {
        long id;
        QWidget* scrolled_widget;
        int dx, dy;
    };
    long sip_serial;
    QList<ScrollInProgress> sip_list;

    
    Atom *net_supported_list;
    
    Window *net_virtual_root_list;
    
    Window wm_client_leader;

    QX11InfoData *screens;
    int screenCount;
    int defaultScreen;

    Time time;
    Time userTime;

    QString default_im;

    
    static inline void ignoreBadwindow() {
        qt_x11Data->ignore_badwindow = true;
        qt_x11Data->seen_badwindow = false;
    }

    
    static inline bool badwindow() {
        qt_x11Data->ignore_badwindow = false;
        return qt_x11Data->seen_badwindow;
    }

    bool ignore_badwindow;
    bool seen_badwindow;

    
    int visual_class;
    int visual_id;
    int color_count;
    bool custom_cmap;

    
    Visual *visual;
    Colormap colormap;


    enum { solid_fill_count = 16 };
    struct SolidFills {
        XRenderColor color;
        int screen;
        Picture picture;
    } solid_fills[solid_fill_count];
    enum { pattern_fill_count = 16 };
    struct PatternFills {
        XRenderColor color;
        XRenderColor bg_color;
        int screen;
        int style;
        bool opaque;
        Picture picture;
    } pattern_fills[pattern_fill_count];
    Picture getSolidFill(int screen, const QColor &c);
    XRenderColor preMultiply(const QColor &c);


    bool has_fontconfig;
    qreal fc_scale;
    bool fc_antialias;
    int fc_hint_style;

    char *startupId;

     
    enum X11Atom {
        
        WM_PROTOCOLS,
        WM_DELETE_WINDOW,
        WM_TAKE_FOCUS,
        _NET_WM_PING,
        _NET_WM_CONTEXT_HELP,

        
        WM_STATE,
        WM_CHANGE_STATE,

        
        WM_CLIENT_LEADER,
        WM_WINDOW_ROLE,
        SM_CLIENT_ID,

        
        CLIPBOARD,
        INCR,
        TARGETS,
        MULTIPLE,
        TIMESTAMP,
        CLIP_TEMPORARY,
        _QT_SELECTION,
        _QT_CLIPBOARD_SENTINEL,
        _QT_SELECTION_SENTINEL,

        RESOURCE_MANAGER,

        _XSETROOT_ID,

        _QT_SCROLL_DONE,
        _QT_INPUT_ENCODING,
        _QT_SIZEGRIP,

        _MOTIF_WM_HINTS,

        DTWM_IS_RUNNING,
        KWIN_RUNNING,
        KWM_RUNNING,
        GNOME_BACKGROUND_PROPERTIES,
        ENLIGHTENMENT_DESKTOP,
        _SGI_DESKS_MANAGER,

        
        _NET_SUPPORTED,
        _NET_VIRTUAL_ROOTS,
        _NET_WORKAREA,

        _NET_WM_NAME,
        _NET_WM_ICON_NAME,
        _NET_WM_ICON,

        _NET_WM_PID,

        _NET_WM_WINDOW_OPACITY,

        _NET_WM_STATE,
        _NET_WM_STATE_ABOVE,
        _NET_WM_STATE_FULLSCREEN,
        _NET_WM_STATE_MAXIMIZED_HORZ,
        _NET_WM_STATE_MAXIMIZED_VERT,
        _NET_WM_STATE_MODAL,
        _NET_WM_STATE_STAYS_ON_TOP,

        _NET_WM_USER_TIME,

        _NET_WM_WINDOW_TYPE,
        _NET_WM_WINDOW_TYPE_DIALOG,
        _NET_WM_WINDOW_TYPE_MENU,
        _NET_WM_WINDOW_TYPE_NORMAL,
        _KDE_NET_WM_WINDOW_TYPE_OVERRIDE,
        _NET_WM_WINDOW_TYPE_SPLASH,
        _NET_WM_WINDOW_TYPE_TOOLBAR,
        _NET_WM_WINDOW_TYPE_UTILITY,

        _KDE_NET_WM_FRAME_STRUT,

        _NET_STARTUP_INFO,
        _NET_STARTUP_INFO_BEGIN,

        
        COMPOUND_TEXT,
        TEXT,
        UTF8_STRING,

        
        XdndEnter,
        XdndPosition,
        XdndStatus,
        XdndLeave,
        XdndDrop,
        XdndFinished,
        XdndTypelist,
        XdndActionList,

        XdndSelection,

        XdndAware,
        XdndProxy,

        XdndActionCopy,
        XdndActionLink,
        XdndActionMove,
        XdndActionPrivate,

        
        _MOTIF_DRAG_AND_DROP_MESSAGE,
        _MOTIF_DRAG_INITIATOR_INFO,
        _MOTIF_DRAG_RECEIVER_INFO,
        _MOTIF_DRAG_WINDOW,
        _MOTIF_DRAG_TARGETS,

        XmTRANSFER_SUCCESS,
        XmTRANSFER_FAILURE,

        NPredefinedAtoms,

        _QT_SETTINGS_TIMESTAMP = NPredefinedAtoms,
        NAtoms
    };
    Atom atoms[NAtoms];
};

extern QX11Data *qt_x11Data;





enum {
    XFocusOut = 10,
    XFocusIn = 9,
    XKeyPress = 2,
    XKeyRelease = 3,
    XNone = 0L,
    XRevertToParent = 2,
    XGrayScale = 1,
    XCursorShape = 0
};
#line 559 "../../include/QtGui/private/../../../src/gui/kernel/qt_x11_p.h"





template <> class QTypeInfo<XPoint> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(XPoint)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "XPoint"; } };
template <> class QTypeInfo<XRectangle> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(XRectangle)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "XRectangle"; } };
template <> class QTypeInfo<XChar2b> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(XChar2b)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "XChar2b"; } };

template <> class QTypeInfo<XGlyphElt32> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(XGlyphElt32)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "XGlyphElt32"; } };


#line 2 "../../include/QtGui/private/qt_x11_p.h"
#line 36 "../../include/QtGui/private/../../../src/gui/text/qfontengine_x11_p.h"
#line 1 "/usr/include/freetype2/ft2build.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


   
   
   
   
   
   
   
   
   





#line 1 "/usr/include/freetype2/freetype/config/ftheader.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 





   
   
   
   
   
   
   
   
   
   
   







   
   
   
   
   
   
   
   
   
   
   







   
   
   
   
   

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   


   

   
   
   
   
   
   
   
   
   





   
   
   
   
   
   
   
   
   





   
   
   
   
   
   
   
   
   





   
   
   
   
   
   
   
   
   
   





   

   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   



   








#line 576 "/usr/include/freetype2/freetype/config/ftheader.h"








   

#line 1 "/usr/include/freetype2/freetype/internal/internal.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


   
   
   
   
   
   


#line 39 "/usr/include/freetype2/freetype/internal/internal.h"











 
#line 588 "/usr/include/freetype2/freetype/config/ftheader.h"





 
#line 35 "/usr/include/freetype2/ft2build.h"




 
#line 41 "../../include/QtGui/private/../../../src/gui/text/qfontengine_x11_p.h"
#line 1 "/usr/include/freetype2/freetype/freetype.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


#line 26 "/usr/include/freetype2/freetype/freetype.h"






   
   
   
   
   


   
   
   
   
   
   





#line 1 "/usr/include/freetype2/freetype/config/ftconfig.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   





#line 1 "/usr/include/freetype2/freetype/config/ftoption.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 









extern "C" {

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   


   
   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   





   
   
   
   
   
   
   



   
   
   
   
   
   
   



   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   


   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
#line 418 "/usr/include/freetype2/freetype/config/ftoption.h"


   
   
   
   
   
   
   

   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   



   
   
   
   
   
   
   


   
   
   
   
   
   



   
   
   
   
   



   
   
   
   
   
   
   



   
   
   
   
   
   
   



   
   
   
   
   
   


  





 
 

}





 
#line 44 "/usr/include/freetype2/freetype/config/ftconfig.h"
#line 1 "/usr/include/freetype2/freetype/config/ftstdlib.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


   
   
   
   
   
   
   
   
   
   











   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   









   
   
   
   
   













#line 102 "/usr/include/freetype2/freetype/config/ftstdlib.h"







   
   
   
   
   










   
   
   
   
   


#line 1 "/usr/include/setjmp.h"










  


#ident	"@(#)unixsrc:usr/src/i386/head/setjmp.h /main/1"

#line 27 "/usr/include/setjmp.h"

typedef int	jmp_buf[10];

#line 39 "/usr/include/setjmp.h"


extern "C" {


extern int	setjmp(jmp_buf);
extern void	longjmp(jmp_buf, int);

extern int	_setjmp(jmp_buf);
extern void	_longjmp(jmp_buf, int);




typedef int	sigjmp_buf[128];

extern int	sigsetjmp(sigjmp_buf, int);
extern void	siglongjmp(sigjmp_buf, int);








}
#line 1 "/usr/include/CC/csetjmp"

#line 1 "/usr/include/setjmp.h"










  

#line 5 "/usr/include/CC/csetjmp"



namespace std {
using ::jmp_buf; using ::longjmp;

}	





 
#line 68 "/usr/include/setjmp.h"



#line 132 "/usr/include/freetype2/freetype/config/ftstdlib.h"


                               
                               





   
   
   






 
#line 45 "/usr/include/freetype2/freetype/config/ftconfig.h"

extern "C" {


   
   
   
   
   
   
   
   
   
   


   
   
   
   
   
   
   






   
#line 84 "/usr/include/freetype2/freetype/config/ftconfig.h"

   
   
#line 96 "/usr/include/freetype2/freetype/config/ftconfig.h"


   



   
   





   
   
   
   
   
   
   
   
   


   
   
   
   
   
   
   






   
   
   
   
   
   
  typedef signed short    FT_Int16;
  typedef unsigned short  FT_UInt16;



  typedef signed int      FT_Int32;
  typedef unsigned int    FT_UInt32;

#line 155 "/usr/include/freetype2/freetype/config/ftconfig.h"

   


  typedef int            FT_Fast;
  typedef unsigned int   FT_UFast;

#line 168 "/usr/include/freetype2/freetype/config/ftconfig.h"


   
   
#line 209 "/usr/include/freetype2/freetype/config/ftconfig.h"







   
   
   
   
   
   
   
#line 234 "/usr/include/freetype2/freetype/config/ftconfig.h"


#line 242 "/usr/include/freetype2/freetype/config/ftconfig.h"

#line 250 "/usr/include/freetype2/freetype/config/ftconfig.h"


























































   
   
   

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
#line 338 "/usr/include/freetype2/freetype/config/ftconfig.h"

#line 348 "/usr/include/freetype2/freetype/config/ftconfig.h"


}





 
#line 52 "/usr/include/freetype2/freetype/freetype.h"
#line 1 "/usr/include/freetype2/freetype/fterrors.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   






   
#line 1 "/usr/include/freetype2/freetype/ftmoderr.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   






   
   
   
   
   
   
   

















  extern "C" {





   
   
   
   
   
   
   



  enum {



  FT_Mod_Err_Base = 0,
  FT_Mod_Err_Autofit = 0,
  FT_Mod_Err_BDF = 0,
  FT_Mod_Err_Cache = 0,
  FT_Mod_Err_CFF = 0,
  FT_Mod_Err_CID = 0,
  FT_Mod_Err_Gzip = 0,
  FT_Mod_Err_LZW = 0,
  FT_Mod_Err_OTvalid = 0,
  FT_Mod_Err_PCF = 0,
  FT_Mod_Err_PFR = 0,
  FT_Mod_Err_PSaux = 0,
  FT_Mod_Err_PShinter = 0,
  FT_Mod_Err_PSnames = 0,
  FT_Mod_Err_Raster = 0,
  FT_Mod_Err_SFNT = 0,
  FT_Mod_Err_Smooth = 0,
  FT_Mod_Err_TrueType = 0,
  FT_Mod_Err_Type1 = 0,
  FT_Mod_Err_Type42 = 0,
  FT_Mod_Err_Winfonts = 0,



  FT_Mod_Err_Max };



   
   
   
   
   
   
   



  }











 
#line 91 "/usr/include/freetype2/freetype/fterrors.h"


   
   
   
   
   
   
   











   
   
   





   
   
#line 128 "/usr/include/freetype2/freetype/fterrors.h"







   
   
   








  extern "C" {





   



   





  enum {



   
#line 1 "/usr/include/freetype2/freetype/fterrdef.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


   
   
   
   
   
   
   


   
   


   

  FT_Err_Ok = 0x00,


  FT_Err_Cannot_Open_Resource = 0x01 + 0,

  FT_Err_Unknown_File_Format = 0x02 + 0,

  FT_Err_Invalid_File_Format = 0x03 + 0,

  FT_Err_Invalid_Version = 0x04 + 0,

  FT_Err_Lower_Module_Version = 0x05 + 0,

  FT_Err_Invalid_Argument = 0x06 + 0,

  FT_Err_Unimplemented_Feature = 0x07 + 0,

  FT_Err_Invalid_Table = 0x08 + 0,

  FT_Err_Invalid_Offset = 0x09 + 0,


   

  FT_Err_Invalid_Glyph_Index = 0x10 + 0,

  FT_Err_Invalid_Character_Code = 0x11 + 0,

  FT_Err_Invalid_Glyph_Format = 0x12 + 0,

  FT_Err_Cannot_Render_Glyph = 0x13 + 0,

  FT_Err_Invalid_Outline = 0x14 + 0,

  FT_Err_Invalid_Composite = 0x15 + 0,

  FT_Err_Too_Many_Hints = 0x16 + 0,

  FT_Err_Invalid_Pixel_Size = 0x17 + 0,


   

  FT_Err_Invalid_Handle = 0x20 + 0,

  FT_Err_Invalid_Library_Handle = 0x21 + 0,

  FT_Err_Invalid_Driver_Handle = 0x22 + 0,

  FT_Err_Invalid_Face_Handle = 0x23 + 0,

  FT_Err_Invalid_Size_Handle = 0x24 + 0,

  FT_Err_Invalid_Slot_Handle = 0x25 + 0,

  FT_Err_Invalid_CharMap_Handle = 0x26 + 0,

  FT_Err_Invalid_Cache_Handle = 0x27 + 0,

  FT_Err_Invalid_Stream_Handle = 0x28 + 0,


   

  FT_Err_Too_Many_Drivers = 0x30 + 0,

  FT_Err_Too_Many_Extensions = 0x31 + 0,


   

  FT_Err_Out_Of_Memory = 0x40 + 0,

  FT_Err_Unlisted_Object = 0x41 + 0,


   

  FT_Err_Cannot_Open_Stream = 0x51 + 0,

  FT_Err_Invalid_Stream_Seek = 0x52 + 0,

  FT_Err_Invalid_Stream_Skip = 0x53 + 0,

  FT_Err_Invalid_Stream_Read = 0x54 + 0,

  FT_Err_Invalid_Stream_Operation = 0x55 + 0,

  FT_Err_Invalid_Frame_Operation = 0x56 + 0,

  FT_Err_Nested_Frame_Access = 0x57 + 0,

  FT_Err_Invalid_Frame_Read = 0x58 + 0,


   

  FT_Err_Raster_Uninitialized = 0x60 + 0,

  FT_Err_Raster_Corrupted = 0x61 + 0,

  FT_Err_Raster_Overflow = 0x62 + 0,

  FT_Err_Raster_Negative_Height = 0x63 + 0,


   

  FT_Err_Too_Many_Caches = 0x70 + 0,


   

  FT_Err_Invalid_Opcode = 0x80 + 0,

  FT_Err_Too_Few_Arguments = 0x81 + 0,

  FT_Err_Stack_Overflow = 0x82 + 0,

  FT_Err_Code_Overflow = 0x83 + 0,

  FT_Err_Bad_Argument = 0x84 + 0,

  FT_Err_Divide_By_Zero = 0x85 + 0,

  FT_Err_Invalid_Reference = 0x86 + 0,

  FT_Err_Debug_OpCode = 0x87 + 0,

  FT_Err_ENDF_In_Exec_Stream = 0x88 + 0,

  FT_Err_Nested_DEFS = 0x89 + 0,

  FT_Err_Invalid_CodeRange = 0x8A + 0,

  FT_Err_Execution_Too_Long = 0x8B + 0,

  FT_Err_Too_Many_Function_Defs = 0x8C + 0,

  FT_Err_Too_Many_Instruction_Defs = 0x8D + 0,

  FT_Err_Table_Missing = 0x8E + 0,

  FT_Err_Horiz_Header_Missing = 0x8F + 0,

  FT_Err_Locations_Missing = 0x90 + 0,

  FT_Err_Name_Table_Missing = 0x91 + 0,

  FT_Err_CMap_Table_Missing = 0x92 + 0,

  FT_Err_Hmtx_Table_Missing = 0x93 + 0,

  FT_Err_Post_Table_Missing = 0x94 + 0,

  FT_Err_Invalid_Horiz_Metrics = 0x95 + 0,

  FT_Err_Invalid_CharMap_Format = 0x96 + 0,

  FT_Err_Invalid_PPem = 0x97 + 0,

  FT_Err_Invalid_Vert_Metrics = 0x98 + 0,

  FT_Err_Could_Not_Find_Context = 0x99 + 0,

  FT_Err_Invalid_Post_Table_Format = 0x9A + 0,

  FT_Err_Invalid_Post_Table = 0x9B + 0,


   

  FT_Err_Syntax_Error = 0xA0 + 0,

  FT_Err_Stack_Underflow = 0xA1 + 0,

  FT_Err_Ignore = 0xA2 + 0,


   

  FT_Err_Missing_Startfont_Field = 0xB0 + 0,

  FT_Err_Missing_Font_Field = 0xB1 + 0,

  FT_Err_Missing_Size_Field = 0xB2 + 0,

  FT_Err_Missing_Chars_Field = 0xB3 + 0,

  FT_Err_Missing_Startchar_Field = 0xB4 + 0,

  FT_Err_Missing_Encoding_Field = 0xB5 + 0,

  FT_Err_Missing_Bbx_Field = 0xB6 + 0,



 
#line 168 "/usr/include/freetype2/freetype/fterrors.h"



  FT_Err_Max };



   
   
   
   
   
   
   


  }













   







 
#line 53 "/usr/include/freetype2/freetype/freetype.h"
#line 1 "/usr/include/freetype2/freetype/fttypes.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 






#line 1 "/usr/include/freetype2/freetype/ftsystem.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 









extern "C" {


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   


   
   
   
   
   


   
   
   
   
   
   
   
   
   
  typedef struct FT_MemoryRec_*  FT_Memory;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef void*
  (*FT_Alloc_Func)( FT_Memory  memory,
                    long       size );


   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef void
  (*FT_Free_Func)( FT_Memory  memory,
                   void*      block );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef void*
  (*FT_Realloc_Func)( FT_Memory  memory,
                      long       cur_size,
                      long       new_size,
                      void*      block );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  struct  FT_MemoryRec_
  {
    void*            user;
    FT_Alloc_Func    alloc;
    FT_Free_Func     free;
    FT_Realloc_Func  realloc;
  };


   
   
   
   
   


   
   
   
   
   
   
   
   
  typedef struct FT_StreamRec_*  FT_Stream;


   
   
   
   
   
   
   
   
   
  typedef union  FT_StreamDesc_
  {
    long   value;
    void*  pointer;

  } FT_StreamDesc;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef unsigned long
  (*FT_Stream_IoFunc)( FT_Stream       stream,
                       unsigned long   offset,
                       unsigned char*  buffer,
                       unsigned long   count );


   
   
   
   
   
   
   
   
   
   
   
  typedef void
  (*FT_Stream_CloseFunc)( FT_Stream  stream );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_StreamRec_
  {
    unsigned char*       base;
    unsigned long        size;
    unsigned long        pos;

    FT_StreamDesc        descriptor;
    FT_StreamDesc        pathname;
    FT_Stream_IoFunc     read;
    FT_Stream_CloseFunc  close;

    FT_Memory            memory;
    unsigned char*       cursor;
    unsigned char*       limit;

  } FT_StreamRec;


   


}




 
#line 26 "/usr/include/freetype2/freetype/fttypes.h"
#line 1 "/usr/include/freetype2/freetype/ftimage.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

   
   
   
   
   
   






 





extern "C" {


   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
   
  typedef signed long  FT_Pos;


   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Vector_
  {
    FT_Pos  x;
    FT_Pos  y;

  } FT_Vector;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_BBox_
  {
    FT_Pos  xMin, yMin;
    FT_Pos  xMax, yMax;

  } FT_BBox;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef enum  FT_Pixel_Mode_
  {
    FT_PIXEL_MODE_NONE = 0,
    FT_PIXEL_MODE_MONO,
    FT_PIXEL_MODE_GRAY,
    FT_PIXEL_MODE_GRAY2,
    FT_PIXEL_MODE_GRAY4,
    FT_PIXEL_MODE_LCD,
    FT_PIXEL_MODE_LCD_V,

    FT_PIXEL_MODE_MAX       

  } FT_Pixel_Mode;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   






  

#line 232 "/usr/include/freetype2/freetype/ftimage.h"


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Bitmap_
  {
    int             rows;
    int             width;
    int             pitch;
    unsigned char*  buffer;
    short           num_grays;
    char            pixel_mode;
    char            palette_mode;
    void*           palette;

  } FT_Bitmap;


   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Outline_
  {
    short       n_contours;       
    short       n_points;         

    FT_Vector*  points;           
    char*       tags;             
    short*      contours;         

    int         flags;            

  } FT_Outline;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   










 
















 
#line 447 "/usr/include/freetype2/freetype/ftimage.h"

   



















   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef int
  (*FT_Outline_MoveToFunc)( FT_Vector*  to,
                            void*       user );



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef int
  (*FT_Outline_LineToFunc)( FT_Vector*  to,
                            void*       user );



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef int
  (*FT_Outline_ConicToFunc)( FT_Vector*  control,
                             FT_Vector*  to,
                             void*       user );



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef int
  (*FT_Outline_CubicToFunc)( FT_Vector*  control1,
                             FT_Vector*  control2,
                             FT_Vector*  to,
                             void*       user );




   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Outline_Funcs_
  {
    FT_Outline_MoveToFunc   move_to;
    FT_Outline_LineToFunc   line_to;
    FT_Outline_ConicToFunc  conic_to;
    FT_Outline_CubicToFunc  cubic_to;

    int                     shift;
    FT_Pos                  delta;

  } FT_Outline_Funcs;


   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
#line 665 "/usr/include/freetype2/freetype/ftimage.h"


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef enum  FT_Glyph_Format_
  {
    FT_GLYPH_FORMAT_NONE = ( ( (unsigned long)0 << 24 ) | ( (unsigned long)0 << 16 ) | ( (unsigned long)0 << 8 ) | (unsigned long)0 ),

    FT_GLYPH_FORMAT_COMPOSITE = ( ( (unsigned long)'c' << 24 ) | ( (unsigned long)'o' << 16 ) | ( (unsigned long)'m' << 8 ) | (unsigned long)'p' ),
    FT_GLYPH_FORMAT_BITMAP = ( ( (unsigned long)'b' << 24 ) | ( (unsigned long)'i' << 16 ) | ( (unsigned long)'t' << 8 ) | (unsigned long)'s' ),
    FT_GLYPH_FORMAT_OUTLINE = ( ( (unsigned long)'o' << 24 ) | ( (unsigned long)'u' << 16 ) | ( (unsigned long)'t' << 8 ) | (unsigned long)'l' ),
    FT_GLYPH_FORMAT_PLOTTER = ( ( (unsigned long)'p' << 24 ) | ( (unsigned long)'l' << 16 ) | ( (unsigned long)'o' << 8 ) | (unsigned long)'t' )

  } FT_Glyph_Format;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   







   
   
   
   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
  typedef struct FT_RasterRec_*  FT_Raster;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Span_
  {
    short           x;
    unsigned short  len;
    unsigned char   coverage;

  } FT_Span;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef void
  (*FT_SpanFunc)( int       y,
                  int       count,
                  FT_Span*  spans,
                  void*     user );




   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef int
  (*FT_Raster_BitTest_Func)( int    y,
                             int    x,
                             void*  user );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef void
  (*FT_Raster_BitSet_Func)( int    y,
                            int    x,
                            void*  user );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   





   






   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Raster_Params_
  {
    const FT_Bitmap*        target;
    const void*             source;
    int                     flags;
    FT_SpanFunc             gray_spans;
    FT_SpanFunc             black_spans;
    FT_Raster_BitTest_Func  bit_test;      
    FT_Raster_BitSet_Func   bit_set;       
    void*                   user;
    FT_BBox                 clip_box;

  } FT_Raster_Params;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef int
  (*FT_Raster_NewFunc)( void*       memory,
                        FT_Raster*  raster );



   
   
   
   
   
   
   
   
   
   
   
  typedef void
  (*FT_Raster_DoneFunc)( FT_Raster  raster );



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef void
  (*FT_Raster_ResetFunc)( FT_Raster       raster,
                          unsigned char*  pool_base,
                          unsigned long   pool_size );



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef int
  (*FT_Raster_SetModeFunc)( FT_Raster      raster,
                            unsigned long  mode,
                            void*          args );



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef int
  (*FT_Raster_RenderFunc)( FT_Raster          raster,
                           FT_Raster_Params*  params );



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Raster_Funcs_
  {
    FT_Glyph_Format         glyph_format;
    FT_Raster_NewFunc       raster_new;
    FT_Raster_ResetFunc     raster_reset;
    FT_Raster_SetModeFunc   raster_set_mode;
    FT_Raster_RenderFunc    raster_render;
    FT_Raster_DoneFunc      raster_done;

  } FT_Raster_Funcs;


   


}




 
#line 27 "/usr/include/freetype2/freetype/fttypes.h"




extern "C" {


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   


   
   
   
   
   
   
   
   
  typedef unsigned char  FT_Bool;


   
   
   
   
   
   
   
   
   
  typedef signed short  FT_FWord;    


   
   
   
   
   
   
   
   
   
  typedef unsigned short  FT_UFWord;   


   
   
   
   
   
   
   
   
  typedef signed char  FT_Char;


   
   
   
   
   
   
   
   
  typedef unsigned char  FT_Byte;


   
   
   
   
   
   
   
   
  typedef const FT_Byte*  FT_Bytes;


   
   
   
   
   
   
   
   
  typedef FT_UInt32  FT_Tag;


   
   
   
   
   
   
   
   
  typedef char  FT_String;


   
   
   
   
   
   
   
   
  typedef signed short  FT_Short;


   
   
   
   
   
   
   
   
  typedef unsigned short  FT_UShort;


   
   
   
   
   
   
   
   
  typedef signed int  FT_Int;


   
   
   
   
   
   
   
   
  typedef unsigned int  FT_UInt;


   
   
   
   
   
   
   
   
  typedef signed long  FT_Long;


   
   
   
   
   
   
   
   
  typedef unsigned long  FT_ULong;


   
   
   
   
   
   
   
   
  typedef signed short  FT_F2Dot14;


   
   
   
   
   
   
   
   
   
  typedef signed long  FT_F26Dot6;


   
   
   
   
   
   
   
   
   
  typedef signed long  FT_Fixed;


   
   
   
   
   
   
   
   
   
  typedef int  FT_Error;


   
   
   
   
   
   
   
   
  typedef void*  FT_Pointer;


   
   
   
   
   
   
   
   
   
   
  typedef size_t  FT_Offset;


   
   
   
   
   
   
   
   
   
   
  typedef ptrdiff_t  FT_PtrDist;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_UnitVector_
  {
    FT_F2Dot14  x;
    FT_F2Dot14  y;

  } FT_UnitVector;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Matrix_
  {
    FT_Fixed  xx, xy;
    FT_Fixed  yx, yy;

  } FT_Matrix;


   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Data_
  {
    const FT_Byte*  pointer;
    FT_Int          length;

  } FT_Data;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef void  (*FT_Generic_Finalizer)(void*  object);


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Generic_
  {
    void*                 data;
    FT_Generic_Finalizer  finalizer;

  } FT_Generic;


   
   
   
   
   
   
   
   
   
   
   
   
   







   
   
   
   
   
   
   


   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
  typedef struct FT_ListNodeRec_*  FT_ListNode;


   
   
   
   
   
   
   
   
  typedef struct FT_ListRec_*  FT_List;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_ListNodeRec_
  {
    FT_ListNode  prev;
    FT_ListNode  next;
    void*        data;

  } FT_ListNodeRec;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_ListRec_
  {
    FT_ListNode  head;
    FT_ListNode  tail;

  } FT_ListRec;


   



   


   




}




 
#line 54 "/usr/include/freetype2/freetype/freetype.h"


extern "C" {


   
   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Glyph_Metrics_
  {
    FT_Pos  width;
    FT_Pos  height;

    FT_Pos  horiBearingX;
    FT_Pos  horiBearingY;
    FT_Pos  horiAdvance;

    FT_Pos  vertBearingX;
    FT_Pos  vertBearingY;
    FT_Pos  vertAdvance;

  } FT_Glyph_Metrics;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Bitmap_Size_
  {
    FT_Short  height;
    FT_Short  width;

    FT_Pos    size;

    FT_Pos    x_ppem;
    FT_Pos    y_ppem;

  } FT_Bitmap_Size;


   
   
   
   
   
   
   

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct FT_LibraryRec_  *FT_Library;


   
   
   
   
   
   
   
   
   
   
  typedef struct FT_ModuleRec_*  FT_Module;


   
   
   
   
   
   
   
   
   
  typedef struct FT_DriverRec_*  FT_Driver;


   
   
   
   
   
   
   
   
   
   
   
  typedef struct FT_RendererRec_*  FT_Renderer;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct FT_FaceRec_*  FT_Face;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct FT_SizeRec_*  FT_Size;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct FT_GlyphSlotRec_*  FT_GlyphSlot;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct FT_CharMapRec_*  FT_CharMap;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   

#line 493 "/usr/include/freetype2/freetype/freetype.h"




   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef enum  FT_Encoding_
  {
    FT_ENCODING_NONE = ( ( (FT_UInt32)(0) << 24 ) | ( (FT_UInt32)(0) << 16 ) | ( (FT_UInt32)(0) << 8 ) | (FT_UInt32)(0) ),

    FT_ENCODING_MS_SYMBOL = ( ( (FT_UInt32)('s') << 24 ) | ( (FT_UInt32)('y') << 16 ) | ( (FT_UInt32)('m') << 8 ) | (FT_UInt32)('b') ),
    FT_ENCODING_UNICODE = ( ( (FT_UInt32)('u') << 24 ) | ( (FT_UInt32)('n') << 16 ) | ( (FT_UInt32)('i') << 8 ) | (FT_UInt32)('c') ),

    FT_ENCODING_SJIS = ( ( (FT_UInt32)('s') << 24 ) | ( (FT_UInt32)('j') << 16 ) | ( (FT_UInt32)('i') << 8 ) | (FT_UInt32)('s') ),
    FT_ENCODING_GB2312 = ( ( (FT_UInt32)('g') << 24 ) | ( (FT_UInt32)('b') << 16 ) | ( (FT_UInt32)(' ') << 8 ) | (FT_UInt32)(' ') ),
    FT_ENCODING_BIG5 = ( ( (FT_UInt32)('b') << 24 ) | ( (FT_UInt32)('i') << 16 ) | ( (FT_UInt32)('g') << 8 ) | (FT_UInt32)('5') ),
    FT_ENCODING_WANSUNG = ( ( (FT_UInt32)('w') << 24 ) | ( (FT_UInt32)('a') << 16 ) | ( (FT_UInt32)('n') << 8 ) | (FT_UInt32)('s') ),
    FT_ENCODING_JOHAB = ( ( (FT_UInt32)('j') << 24 ) | ( (FT_UInt32)('o') << 16 ) | ( (FT_UInt32)('h') << 8 ) | (FT_UInt32)('a') ),

     
    FT_ENCODING_MS_SJIS    = FT_ENCODING_SJIS,
    FT_ENCODING_MS_GB2312  = FT_ENCODING_GB2312,
    FT_ENCODING_MS_BIG5    = FT_ENCODING_BIG5,
    FT_ENCODING_MS_WANSUNG = FT_ENCODING_WANSUNG,
    FT_ENCODING_MS_JOHAB   = FT_ENCODING_JOHAB,

    FT_ENCODING_ADOBE_STANDARD = ( ( (FT_UInt32)('A') << 24 ) | ( (FT_UInt32)('D') << 16 ) | ( (FT_UInt32)('O') << 8 ) | (FT_UInt32)('B') ),
    FT_ENCODING_ADOBE_EXPERT = ( ( (FT_UInt32)('A') << 24 ) | ( (FT_UInt32)('D') << 16 ) | ( (FT_UInt32)('B') << 8 ) | (FT_UInt32)('E') ),
    FT_ENCODING_ADOBE_CUSTOM = ( ( (FT_UInt32)('A') << 24 ) | ( (FT_UInt32)('D') << 16 ) | ( (FT_UInt32)('B') << 8 ) | (FT_UInt32)('C') ),
    FT_ENCODING_ADOBE_LATIN_1 = ( ( (FT_UInt32)('l') << 24 ) | ( (FT_UInt32)('a') << 16 ) | ( (FT_UInt32)('t') << 8 ) | (FT_UInt32)('1') ),

    FT_ENCODING_OLD_LATIN_2 = ( ( (FT_UInt32)('l') << 24 ) | ( (FT_UInt32)('a') << 16 ) | ( (FT_UInt32)('t') << 8 ) | (FT_UInt32)('2') ),

    FT_ENCODING_APPLE_ROMAN = ( ( (FT_UInt32)('a') << 24 ) | ( (FT_UInt32)('r') << 16 ) | ( (FT_UInt32)('m') << 8 ) | (FT_UInt32)('n') )

  } FT_Encoding;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
#line 703 "/usr/include/freetype2/freetype/freetype.h"







   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_CharMapRec_
  {
    FT_Face      face;
    FT_Encoding  encoding;
    FT_UShort    platform_id;
    FT_UShort    encoding_id;

  } FT_CharMapRec;


   
   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct FT_Face_InternalRec_*  FT_Face_Internal;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_FaceRec_
  {
    FT_Long           num_faces;
    FT_Long           face_index;

    FT_Long           face_flags;
    FT_Long           style_flags;

    FT_Long           num_glyphs;

    FT_String*        family_name;
    FT_String*        style_name;

    FT_Int            num_fixed_sizes;
    FT_Bitmap_Size*   available_sizes;

    FT_Int            num_charmaps;
    FT_CharMap*       charmaps;

    FT_Generic        generic;

     
    FT_BBox           bbox;

    FT_UShort         units_per_EM;
    FT_Short          ascender;
    FT_Short          descender;
    FT_Short          height;

    FT_Short          max_advance_width;
    FT_Short          max_advance_height;

    FT_Short          underline_position;
    FT_Short          underline_thickness;

    FT_GlyphSlot      glyph;
    FT_Size           size;
    FT_CharMap        charmap;

     

    FT_Driver         driver;
    FT_Memory         memory;
    FT_Stream         stream;

    FT_ListRec        sizes_list;

    FT_Generic        autohint;
    void*             extensions;

    FT_Face_Internal  internal;

     

  } FT_FaceRec;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
#line 1054 "/usr/include/freetype2/freetype/freetype.h"

   


   
   
   
   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   
   




    


   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   
  typedef struct FT_Size_InternalRec_*  FT_Size_Internal;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Size_Metrics_
  {
    FT_UShort  x_ppem;       
    FT_UShort  y_ppem;       

    FT_Fixed   x_scale;      
    FT_Fixed   y_scale;      

    FT_Pos     ascender;     
    FT_Pos     descender;    
    FT_Pos     height;       
    FT_Pos     max_advance;  

  } FT_Size_Metrics;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_SizeRec_
  {
    FT_Face           face;       
    FT_Generic        generic;    
    FT_Size_Metrics   metrics;    
    FT_Size_Internal  internal;

  } FT_SizeRec;


   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct FT_SubGlyphRec_*  FT_SubGlyph;


   
   
   
   
   
   
   
   
   
  typedef struct FT_Slot_InternalRec_*  FT_Slot_Internal;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_GlyphSlotRec_
  {
    FT_Library        library;
    FT_Face           face;
    FT_GlyphSlot      next;
    FT_UInt           reserved;        
    FT_Generic        generic;

    FT_Glyph_Metrics  metrics;
    FT_Fixed          linearHoriAdvance;
    FT_Fixed          linearVertAdvance;
    FT_Vector         advance;

    FT_Glyph_Format   format;

    FT_Bitmap         bitmap;
    FT_Int            bitmap_left;
    FT_Int            bitmap_top;

    FT_Outline        outline;

    FT_UInt           num_subglyphs;
    FT_SubGlyph       subglyphs;

    void*             control_data;
    long              control_len;

    FT_Pos            lsb_delta;
    FT_Pos            rsb_delta;

    void*             other;

    FT_Slot_Internal  internal;

  } FT_GlyphSlotRec;


   
   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Init_FreeType( FT_Library  *alibrary );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" void
  FT_Library_Version( FT_Library   library,
                      FT_Int      *amajor,
                      FT_Int      *aminor,
                      FT_Int      *apatch );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Done_FreeType( FT_Library  library );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   













   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Parameter_
  {
    FT_ULong    tag;
    FT_Pointer  data;

  } FT_Parameter;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef struct  FT_Open_Args_
  {
    FT_UInt         flags;
    const FT_Byte*  memory_base;
    FT_Long         memory_size;
    FT_String*      pathname;
    FT_Stream       stream;
    FT_Module       driver;
    FT_Int          num_params;
    FT_Parameter*   params;

  } FT_Open_Args;


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_New_Face( FT_Library   library,
               const char*  filepathname,
               FT_Long      face_index,
               FT_Face     *aface );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_New_Memory_Face( FT_Library      library,
                      const FT_Byte*  file_base,
                      FT_Long         file_size,
                      FT_Long         face_index,
                      FT_Face        *aface );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Open_Face( FT_Library           library,
                const FT_Open_Args*  args,
                FT_Long              face_index,
                FT_Face             *aface );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Attach_File( FT_Face      face,
                  const char*  filepathname );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Attach_Stream( FT_Face        face,
                    FT_Open_Args*  parameters );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Done_Face( FT_Face  face );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Set_Char_Size( FT_Face     face,
                    FT_F26Dot6  char_width,
                    FT_F26Dot6  char_height,
                    FT_UInt     horz_resolution,
                    FT_UInt     vert_resolution );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Set_Pixel_Sizes( FT_Face  face,
                      FT_UInt  pixel_width,
                      FT_UInt  pixel_height );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Load_Glyph( FT_Face   face,
                 FT_UInt   glyph_index,
                 FT_Int32  load_flags );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Load_Char( FT_Face   face,
                FT_ULong  char_code,
                FT_Int32  load_flags );


 








































































































































 
#line 2347 "/usr/include/freetype2/freetype/freetype.h"

   



   










   


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" void
  FT_Set_Transform( FT_Face     face,
                    FT_Matrix*  matrix,
                    FT_Vector*  delta );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef enum  FT_Render_Mode_
  {
    FT_RENDER_MODE_NORMAL = 0,
    FT_RENDER_MODE_LIGHT,
    FT_RENDER_MODE_MONO,
    FT_RENDER_MODE_LCD,
    FT_RENDER_MODE_LCD_V,

    FT_RENDER_MODE_MAX

  } FT_Render_Mode;


   
   
   
   
   
   
   
   
   
   
   
   
   




   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Render_Glyph( FT_GlyphSlot    slot,
                   FT_Render_Mode  render_mode );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  typedef enum  FT_Kerning_Mode_
  {
    FT_KERNING_DEFAULT  = 0,
    FT_KERNING_UNFITTED,
    FT_KERNING_UNSCALED

  } FT_Kerning_Mode;


   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Get_Kerning( FT_Face     face,
                  FT_UInt     left_glyph,
                  FT_UInt     right_glyph,
                  FT_UInt     kern_mode,
                  FT_Vector  *akerning );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Get_Glyph_Name( FT_Face     face,
                     FT_UInt     glyph_index,
                     FT_Pointer  buffer,
                     FT_UInt     buffer_max );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" const char*
  FT_Get_Postscript_Name( FT_Face  face );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Select_Charmap( FT_Face      face,
                     FT_Encoding  encoding );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Error
  FT_Set_Charmap( FT_Face     face,
                  FT_CharMap  charmap );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Int
  FT_Get_Charmap_Index( FT_CharMap  charmap );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_UInt
  FT_Get_Char_Index( FT_Face   face,
                     FT_ULong  charcode );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_ULong
  FT_Get_First_Char( FT_Face   face,
                     FT_UInt  *agindex );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_ULong
  FT_Get_Next_Char( FT_Face    face,
                    FT_ULong   char_code,
                    FT_UInt   *agindex );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_UInt
  FT_Get_Name_Index( FT_Face     face,
                     FT_String*  glyph_name );



   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Long
  FT_MulDiv( FT_Long  a,
             FT_Long  b,
             FT_Long  c );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Long
  FT_MulFix( FT_Long  a,
             FT_Long  b );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Long
  FT_DivFix( FT_Long  a,
             FT_Long  b );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Fixed
  FT_RoundFix( FT_Fixed  a );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Fixed
  FT_CeilFix( FT_Fixed  a );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" FT_Fixed
  FT_FloorFix( FT_Fixed  a );


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
  extern "C" void
  FT_Vector_Transform( FT_Vector*        vec,
                       const FT_Matrix*  matrix );


   


}




 
#line 42 "../../include/QtGui/private/../../../src/gui/text/qfontengine_x11_p.h"


struct QFreetypeFace;



class QFontEngineMultiXLFD : public QFontEngineMulti
{
public:
    QFontEngineMultiXLFD(const QFontDef &r, const QList<int> &l, int s);
    ~QFontEngineMultiXLFD();

    void loadEngine(int at);

private:
    QList<int> encodings;
    int screen;
    QFontDef request;
};

class QFontEngineXLFD : public QFontEngine
{
public:
    QFontEngineXLFD(XFontStruct *f, const QByteArray &name, int mib);
    ~QFontEngineXLFD();

    QFontEngine::FaceId faceId() const;
    QFontEngine::Properties properties() const;

    void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics);

    QByteArray getSfntTable(uint tag) const;
    int synthesized() const;

    bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs,
                      QTextEngine::ShaperFlags flags) const;

    glyph_metrics_t boundingBox(const QGlyphLayout *glyphs, int numGlyphs);
    glyph_metrics_t boundingBox(glyph_t glyph);

    void addOutlineToPath(qreal x, qreal y, const QGlyphLayout *glyphs, int numGlyphs, QPainterPath *path, QTextItem::RenderFlags);
    QFixed ascent() const;
    QFixed descent() const;
    QFixed leading() const;
    qreal maxCharWidth() const;
    qreal minLeftBearing() const;
    qreal minRightBearing() const;

    inline Type type() const
    { return QFontEngine::XLFD; }

    bool canRender(const QChar *string, int len);
    const char *name() const;

    inline XFontStruct *fontStruct() const
    { return _fs; }


    FT_Face non_locked_face() const;
    glyph_t glyphIndexToFreetypeGlyphIndex(glyph_t g) const;

    uint toUnicode(glyph_t g) const;

private:
    XFontStruct *_fs;
    QByteArray _name;
    QTextCodec *_codec;
    int _cmap;
    int lbearing, rbearing;
    mutable QFontEngine::FaceId face_id;
    mutable QFreetypeFace *freetype;
    mutable int synth;
};



class  QFontEngineMultiFT : public QFontEngineMulti
{
public:
    QFontEngineMultiFT(FcFontSet *fs, int s, const QFontDef &request);
    ~QFontEngineMultiFT();

    void loadEngine(int at);

private:
    FcFontSet *fontSet;
    int screen;
};

class  QFontEngineFT : public QFontEngine
{
public:
    explicit QFontEngineFT(FcPattern *pattern, const QFontDef &fd, int screen);
    ~QFontEngineFT();

    QFontEngine::FaceId faceId() const;
    QFontEngine::Properties properties() const;
    void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics);
    QByteArray getSfntTable(uint tag) const;
    int synthesized() const;

    bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs,
                      QTextEngine::ShaperFlags flags) const;

    glyph_metrics_t boundingBox(const QGlyphLayout *glyphs, int numGlyphs);
    glyph_metrics_t boundingBox(glyph_t glyph);

    QFixed ascent() const;
    QFixed descent() const;
    QFixed leading() const;
    QFixed xHeight() const;

    qreal maxCharWidth() const;
    qreal minLeftBearing() const;
    qreal minRightBearing() const;
    QFixed lineThickness() const;
    QFixed underlinePosition() const;

    inline Type type() const
    { return QFontEngine::Freetype; }

    bool canRender(const QChar *string, int len);
    inline const char *name() const
    { return "freetype"; }

    void recalcAdvances(int len, QGlyphLayout *glyphs, QTextEngine::ShaperFlags flags) const;
    void doKerning(int , QGlyphLayout *, QTextEngine::ShaperFlags) const;
    void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nglyphs,
                         QPainterPath *path, QTextItem::RenderFlags flags);
    void addOutlineToPath(qreal x, qreal y, const QGlyphLayout *glyphs, int numGlyphs,
                          QPainterPath *path, QTextItem::RenderFlags flags);

    FcPattern *pattern() const { return _pattern; }
    QOpenType *openType() const;

    FT_Face lockFace() const;
    void unlockFace() const;

    FT_Face non_locked_face() const;
    bool drawAsOutline() const { return outline_drawing; }
    bool invalid() const { return xsize == 0 && ysize == 0; }
private:
    QFreetypeFace *freetype;
    QFontEngine::FaceId face_id;

    mutable QFixed lbearing;
    mutable QFixed rbearing;
    QFixed line_thickness;
    QFixed underline_position;
    FcPattern *_pattern;
    int xsize;
    int ysize;
    bool antialias;
    bool outline_drawing;
    int subpixel;
    bool transform;
    int hint_style;
    bool autohint;
    mutable FT_Matrix matrix; 

public:
    enum GlyphFormat {
        Format_None,
        Format_Render = Format_None,
        Format_Mono,
        Format_A8,
        Format_A32
    };

     
    struct Glyph {
        ~Glyph();
        short linearAdvance;
        unsigned char width;
        unsigned char height;
        signed char x;
        signed char y;
        signed char advance;
        signed char format;
        uchar *data;
    };
    Glyph *loadGlyph(uint glyph, GlyphFormat = Format_None) const;

    int xglyph_format;
    GlyphSet glyphSet;

private:
    mutable QOpenType *_openType;
    FT_Size_Metrics metrics;
    mutable QHash<int, Glyph *> glyph_data; 
};



#line 2 "../../include/QtGui/private/qfontengine_x11_p.h"
#line 496 "text/qfontengine_p.h"




class QTestFontEngine : public QFontEngineBox
{
public:
    QTestFontEngine(int size) : QFontEngineBox(size) {}
    Type type() const { return TestFontEngine; }
};

#line 33 "text/qtextengine.cpp"
#line 1 "../../include/QtCore/qstring.h"
#line 34 "text/qtextengine.cpp"
#line 1 "../../include/QtCore/private/qunicodetables_p.h"
#line 35 "text/qtextengine.cpp"
#line 1 "../../include/QtGui/qapplication.h"
#line 1 "../../include/QtGui/../../src/gui/kernel/qapplication.h"



















 




#line 1 "../../include/QtCore/qcoreapplication.h"
#line 1 "../../include/QtCore/../../src/corelib/kernel/qcoreapplication.h"



















 




#line 1 "../../include/QtCore/qobject.h"
#line 26 "../../include/QtCore/../../src/corelib/kernel/qcoreapplication.h"
#line 1 "../../include/QtCore/qcoreevent.h"
#line 27 "../../include/QtCore/../../src/corelib/kernel/qcoreapplication.h"
#line 1 "../../include/QtCore/qeventloop.h"
#line 1 "../../include/QtCore/../../src/corelib/kernel/qeventloop.h"



















 




#line 1 "../../include/QtCore/qobject.h"
#line 26 "../../include/QtCore/../../src/corelib/kernel/qeventloop.h"



typedef QtValidLicenseForCoreModule QtCoreModule;

class QEventLoopPrivate;

class  QEventLoop : public QObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:
    inline QEventLoopPrivate* d_func() { return reinterpret_cast<QEventLoopPrivate * >(d_ptr); } inline const QEventLoopPrivate* d_func() const { return reinterpret_cast<const QEventLoopPrivate * >(d_ptr); } friend class QEventLoopPrivate;

public:
    explicit QEventLoop(QObject *parent = 0);
    ~QEventLoop();

    enum ProcessEventsFlag {
        AllEvents = 0x00,
        ExcludeUserInputEvents = 0x01,
        ExcludeSocketNotifiers = 0x02,
        WaitForMoreEvents = 0x04,

        ExcludeUserInput = ExcludeUserInputEvents,
        WaitForMore = WaitForMoreEvents,

	X11ExcludeTimers = 0x08,
	DeferredDeletion = 0x10
    };
    typedef QFlags<ProcessEventsFlag> ProcessEventsFlags;

    bool processEvents(ProcessEventsFlags flags = AllEvents);
    void processEvents(ProcessEventsFlags flags, int maximumTime);

    int exec(ProcessEventsFlags flags = AllEvents);
    void exit(int returnCode = 0);
    bool isRunning() const;

    void wakeUp();

public :
    void quit();
};

inline QFlags<QEventLoop::ProcessEventsFlags::enum_type> operator|(QEventLoop::ProcessEventsFlags::enum_type f1, QEventLoop::ProcessEventsFlags::enum_type f2) { return QFlags<QEventLoop::ProcessEventsFlags::enum_type>(f1) | f2; } inline QFlags<QEventLoop::ProcessEventsFlags::enum_type> operator|(QEventLoop::ProcessEventsFlags::enum_type f1, QFlags<QEventLoop::ProcessEventsFlags::enum_type> f2) { return f2 | f1; }



#line 2 "../../include/QtCore/qeventloop.h"
#line 28 "../../include/QtCore/../../src/corelib/kernel/qcoreapplication.h"







typedef QtValidLicenseForCoreModule QtCoreModule;





class QCoreApplicationPrivate;
class QTextCodec;
class QTranslator;
class QPostEventList;
class QStringList;

class  QCoreApplication : public QObject
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:
    
    
    

    inline QCoreApplicationPrivate* d_func() { return reinterpret_cast<QCoreApplicationPrivate * >(d_ptr); } inline const QCoreApplicationPrivate* d_func() const { return reinterpret_cast<const QCoreApplicationPrivate * >(d_ptr); } friend class QCoreApplicationPrivate;
public:
    QCoreApplication(int &argc, char **argv);
    ~QCoreApplication();

    static int argc();
    static char **argv();
    static QStringList arguments();

    static void setOrganizationDomain(const QString &orgDomain);
    static QString organizationDomain();
    static void setOrganizationName(const QString &orgName);
    static QString organizationName();
    static void setApplicationName(const QString &application);
    static QString applicationName();

    static QCoreApplication *instance() { return self; }

    static int exec();
    static void processEvents(QEventLoop::ProcessEventsFlags flags = QEventLoop::AllEvents);
    static void processEvents(QEventLoop::ProcessEventsFlags flags, int maxtime);
    static void exit(int retcode=0);

    static bool sendEvent(QObject *receiver, QEvent *event);
    static void postEvent(QObject *receiver, QEvent *event);
    static void sendPostedEvents(QObject *receiver, int event_type);
    static void sendPostedEvents();
    static void removePostedEvents(QObject *receiver);
    static bool hasPendingEvents();

    virtual bool notify(QObject *, QEvent *);

    static bool startingUp();
    static bool closingDown();

    static QString applicationDirPath();
    static QString applicationFilePath();


    static void setLibraryPaths(const QStringList &);
    static QStringList libraryPaths();
    static void addLibraryPath(const QString &);
    static void removeLibraryPath(const QString &);



    static void installTranslator(QTranslator * messageFile);
    static void removeTranslator(QTranslator * messageFile);

    enum Encoding { DefaultCodec, UnicodeUTF8 };
    static QString translate(const char * context,
                             const char * key,
                             const char * comment = 0,
                             Encoding encoding = DefaultCodec);

    static void flush();


    inline  void lock() {}
    inline  void unlock(bool = true) {}
    inline  bool locked() { return false; }
    inline  bool tryLock() { return false; }

    static inline  void processOneEvent()
    { processEvents(QEventLoop::WaitForMoreEvents); }
    static  int enter_loop();
    static  void exit_loop();
    static  int loopLevel();







    static void watchUnixSignal(int signal, bool watch);


    typedef bool (*EventFilter)(void *message, long *result);
    EventFilter setEventFilter(EventFilter filter);
    bool filterEvent(void *message, long *result);

public :
    static void quit();

protected:
    void aboutToQuit();
    void unixSignal(int);

protected:
    bool event(QEvent *);

    virtual bool compressEvent(QEvent *, QObject *receiver, QPostEventList *);

protected:
    QCoreApplication(QCoreApplicationPrivate &p);

private:
    static bool sendSpontaneousEvent(QObject *receiver, QEvent *event);

    void init();

    static QCoreApplication *self;

    friend class QEventDispatcherUNIXPrivate;
    friend class QApplication;
    friend class QApplicationPrivate;
    friend class QETWidget;
    friend class Q3AccelManager;
    friend class QShortcutMap;
    friend class QWidget;
    friend class QWidgetPrivate;
    friend bool qt_sendSpontaneousEvent(QObject*, QEvent*);
    friend  QString qAppName();
};

inline bool QCoreApplication::sendEvent(QObject *receiver, QEvent *event)
{  if (event) event->spont = false; return self ? self->notify(receiver, event) : false; }

inline bool QCoreApplication::sendSpontaneousEvent(QObject *receiver, QEvent *event)
{ if (event) event->spont = true; return self ? self->notify(receiver, event) : false; }

inline void QCoreApplication::sendPostedEvents() { sendPostedEvents(0, 0); }

#line 192 "../../include/QtCore/../../src/corelib/kernel/qcoreapplication.h"

#line 201 "../../include/QtCore/../../src/corelib/kernel/qcoreapplication.h"

typedef void (*QtCleanUpFunction)();

 void qAddPostRoutine(QtCleanUpFunction);
 void qRemovePostRoutine(QtCleanUpFunction);
 QString qAppName();                








#line 2 "../../include/QtCore/qcoreapplication.h"
#line 26 "../../include/QtGui/../../src/gui/kernel/qapplication.h"
#line 1 "../../include/QtGui/qwindowdefs.h"
#line 27 "../../include/QtGui/../../src/gui/kernel/qapplication.h"
#line 1 "../../include/QtCore/qpoint.h"
#line 28 "../../include/QtGui/../../src/gui/kernel/qapplication.h"
#line 1 "../../include/QtCore/qsize.h"
#line 29 "../../include/QtGui/../../src/gui/kernel/qapplication.h"
#line 1 "../../include/QtGui/qcursor.h"
#line 1 "../../include/QtGui/../../src/gui/kernel/qcursor.h"



















 




#line 1 "../../include/QtCore/qpoint.h"
#line 26 "../../include/QtGui/../../src/gui/kernel/qcursor.h"
#line 1 "../../include/QtGui/qwindowdefs.h"
#line 27 "../../include/QtGui/../../src/gui/kernel/qcursor.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QVariant;



 
#line 50 "../../include/QtGui/../../src/gui/kernel/qcursor.h"



struct QCursorData;
class QBitmap;
class QPixmap;





class  QCursor
{
public:
    QCursor();
    QCursor(Qt::CursorShape shape);
    QCursor(const QBitmap &bitmap, const QBitmap &mask, int hotX=-1, int hotY=-1);
    QCursor(const QPixmap &pixmap, int hotX=-1, int hotY=-1);
    QCursor(const QCursor &cursor);
    ~QCursor();
    QCursor &operator=(const QCursor &cursor);
    operator QVariant() const;

    Qt::CursorShape shape() const;
    void setShape(Qt::CursorShape newShape);

    const QBitmap *bitmap() const;
    const QBitmap *mask() const;
    QPixmap pixmap() const;
    QPoint hotSpot() const;

    static QPoint pos();
    static void setPos(int x, int y);
    inline static void setPos(const QPoint &p) { setPos(p.x(), p.y()); }

#line 93 "../../include/QtGui/../../src/gui/kernel/qcursor.h"
    Qt::HANDLE handle() const;
    QCursor(Qt::HANDLE cursor);
    static int x11Screen();





private:
    QCursorData *d;



};







typedef Qt::CursorShape QCursorShape;







 

 QDataStream &operator<<(QDataStream &outS, const QCursor &cursor);
 QDataStream &operator>>(QDataStream &inS, QCursor &cursor);





#line 2 "../../include/QtGui/qcursor.h"
#line 30 "../../include/QtGui/../../src/gui/kernel/qapplication.h"
#line 1 "../../include/QtGui/qwidget.h"
#line 1 "../../include/QtGui/../../src/gui/kernel/qwidget.h"



















 




#line 1 "../../include/QtGui/qwindowdefs.h"
#line 26 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtCore/qobject.h"
#line 27 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtGui/qpaintdevice.h"
#line 28 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtGui/qpalette.h"
#line 29 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtGui/qfont.h"
#line 30 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtGui/qfontmetrics.h"
#line 31 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtGui/qfontinfo.h"
#line 32 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtGui/qsizepolicy.h"
#line 1 "../../include/QtGui/../../src/gui/kernel/qsizepolicy.h"



















 




#line 1 "../../include/QtCore/qobject.h"
#line 26 "../../include/QtGui/../../src/gui/kernel/qsizepolicy.h"



typedef QtValidLicenseForGuiModule QtGuiModule;

class QVariant;

class  QSizePolicy
{
    public: static const QMetaObject staticMetaObject; private:
    
private:
    enum SizePolicyMasks {
        HSize = 4,
        HMask = 0x0f,
        VMask = HMask << HSize
    };
public:
    enum PolicyFlag {
        GrowFlag = 1,
        ExpandFlag = 2,
        ShrinkFlag = 4,
        IgnoreFlag = 8
    };

    enum Policy {
        Fixed = 0,
        Minimum = GrowFlag,
        Maximum = ShrinkFlag,
        Preferred = GrowFlag | ShrinkFlag,
        MinimumExpanding = GrowFlag | ExpandFlag,
        Expanding = GrowFlag | ShrinkFlag | ExpandFlag,
        Ignored = ShrinkFlag|GrowFlag|IgnoreFlag
    };

    QSizePolicy() : data(0) { }

    QSizePolicy(Policy horizontal, Policy vertical)
        : data(horizontal | (vertical<<HSize)) { }

    Policy horizontalPolicy() const { return static_cast<Policy>(data & HMask); }
    Policy verticalPolicy() const { return static_cast<Policy>((data & VMask) >> HSize); }

    void setHorizontalPolicy(Policy d) { data = (data & ~HMask) | d; }
    void setVerticalPolicy(Policy d) { data = (data & ~(HMask << HSize)) | (d << HSize); }

    Qt::Orientations expandingDirections() const {
        Qt::Orientations result;
        if (verticalPolicy() & ExpandFlag)
            result |= Qt::Vertical;
        if (horizontalPolicy() & ExpandFlag)
            result |= Qt::Horizontal;
        return result;
    }

    void setHeightForWidth(bool b) { data = b ? (data | (1 << 2*HSize)) : (data & ~(1 << 2*HSize));  }
    bool hasHeightForWidth() const { return data & (1 << 2*HSize); }

    bool operator==(const QSizePolicy& s) const { return data == s.data; }
    bool operator!=(const QSizePolicy& s) const { return data != s.data; }
    operator QVariant() const; 

    int horizontalStretch() const { return data >> 24; }
    int verticalStretch() const { return (data >> 16) & 0xff; }
    void setHorizontalStretch(uchar stretchFactor) { data = (data&0x00ffffff) | (uint(stretchFactor)<<24); }
    void setVerticalStretch(uchar stretchFactor) { data = (data&0xff00ffff) | (uint(stretchFactor)<<16); }

    void transpose();


    typedef Policy SizeType;

    typedef Qt::Orientations ExpandData;
    enum {
        NoDirection = 0,
        Horizontally = 1,
        Vertically = 2,
        BothDirections = Horizontally | Vertically
    };
#line 113 "../../include/QtGui/../../src/gui/kernel/qsizepolicy.h"

    inline  bool mayShrinkHorizontally() const
        { return horizontalPolicy() & ShrinkFlag; }
    inline  bool mayShrinkVertically() const { return verticalPolicy() & ShrinkFlag; }
    inline  bool mayGrowHorizontally() const { return horizontalPolicy() & GrowFlag; }
    inline  bool mayGrowVertically() const { return verticalPolicy() & GrowFlag; }
    inline  Qt::Orientations expanding() const { return expandingDirections(); }

    explicit QSizePolicy(Policy hor, Policy ver, bool hfw)
        : data(hor | (ver<<HSize) | (hfw ? (1U<<2*HSize) : 0)) { }

    explicit QSizePolicy(Policy hor, Policy ver, uchar hors, uchar vers, bool hfw = false)
        : data(hor | (ver<<HSize) | (hfw ? (1U<<2*HSize) : 0)) {
        setHorizontalStretch(hors);
        setVerticalStretch(vers);
    }

    inline  Policy horData() const { return static_cast<Policy>(data & HMask); }
    inline  Policy verData() const { return static_cast<Policy>((data & VMask) >> HSize); }
    inline  void setHorData(Policy d) { setHorizontalPolicy(d); }
    inline  void setVerData(Policy d) { setVerticalPolicy(d); }

    inline  uint horStretch() const { return horizontalStretch(); }
    inline  uint verStretch() const { return verticalStretch(); }
    inline  void setHorStretch(uchar sf) { setHorizontalStretch(sf); }
    inline  void setVerStretch(uchar sf) { setVerticalStretch(sf); }


private:
    QSizePolicy(int i) : data(i) { }

    quint32 data;
};

inline void QSizePolicy::transpose() {
    Policy hData = horizontalPolicy();
    Policy vData = verticalPolicy();
    uchar hStretch = horizontalStretch();
    uchar vStretch = verticalStretch();
    setHorizontalPolicy(vData);
    setVerticalPolicy(hData);
    setHorizontalStretch(vStretch);
    setVerticalStretch(hStretch);
}



#line 2 "../../include/QtGui/qsizepolicy.h"
#line 33 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtGui/qregion.h"
#line 34 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtGui/qbrush.h"
#line 35 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtGui/qcursor.h"
#line 36 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
#line 1 "../../include/QtGui/qkeysequence.h"
#line 37 "../../include/QtGui/../../src/gui/kernel/qwidget.h"







typedef QtValidLicenseForGuiModule QtGuiModule;

class QLayout;
class QWSRegionManager;
class QStyle;
class QAction;
class QVariant;

class QActionEvent;
class QMouseEvent;
class QWheelEvent;
class QHoverEvent;
class QKeyEvent;
class QFocusEvent;
class QPaintEvent;
class QMoveEvent;
class QResizeEvent;
class QCloseEvent;
class QContextMenuEvent;
class QInputMethodEvent;
class QTabletEvent;
class QDragEnterEvent;
class QDragMoveEvent;
class QDragLeaveEvent;
class QDropEvent;
class QShowEvent;
class QHideEvent;
class QInputContext;
class QIcon;

class QX11Info;


class QWidgetData
{
public:
    WId winid;
    uint widget_attributes;
    Qt::WindowFlags window_flags;
    uint window_state : 4;
    uint focus_policy : 4;
    uint sizehint_forced :1;
    uint is_closing :1;
    uint in_show : 1;
    uint in_set_window_state : 1;
    mutable uint fstrut_dirty : 1;
    uint context_menu_policy : 3;
    uint window_modality : 2;
    uint unused : 14;
    QRect crect;
    mutable QPalette pal;
    QFont fnt;
#line 107 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
    QRect wrect;
};

class QWidgetPrivate;

class  QWidget : public QObject, public QPaintDevice
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:
    inline QWidgetPrivate* d_func() { return reinterpret_cast<QWidgetPrivate * >(d_ptr); } inline const QWidgetPrivate* d_func() const { return reinterpret_cast<const QWidgetPrivate * >(d_ptr); } friend class QWidgetPrivate;

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    


    


    


    
    

    
    
    

public:
    explicit QWidget(QWidget* parent = 0, Qt::WFlags f = 0);

    explicit QWidget(QWidget* parent, const char *name, Qt::WFlags f = 0);

    ~QWidget();

    int devType() const;

    WId winId() const;
    
    QStyle *style() const;
    void setStyle(QStyle *);
    

    bool isTopLevel() const;
    bool isWindow() const;

    bool isModal() const;
    Qt::WindowModality windowModality() const;
    void setWindowModality(Qt::WindowModality windowModality);

    bool isEnabled() const;
    bool isEnabledTo(QWidget*) const;
    bool isEnabledToTLW() const;

public :
    void setEnabled(bool);
    void setDisabled(bool);
    void setWindowModified(bool);

    

public:
    QRect frameGeometry() const;
    const QRect &geometry() const;
    QRect normalGeometry() const;

    int x() const;
    int y() const;
    QPoint pos() const;
    QSize frameSize() const;
    QSize size() const;
    inline int width() const;
    inline int height() const;
    inline QRect rect() const;
    QRect childrenRect() const;
    QRegion childrenRegion() const;

    QSize minimumSize() const;
    QSize maximumSize() const;
    int minimumWidth() const;
    int minimumHeight() const;
    int maximumWidth() const;
    int maximumHeight() const;
    void setMinimumSize(const QSize &);
    void setMinimumSize(int minw, int minh);
    void setMaximumSize(const QSize &);
    void setMaximumSize(int maxw, int maxh);
    void setMinimumWidth(int minw);
    void setMinimumHeight(int minh);
    void setMaximumWidth(int maxw);
    void setMaximumHeight(int maxh);

    QSize sizeIncrement() const;
    void setSizeIncrement(const QSize &);
    void setSizeIncrement(int w, int h);
    QSize baseSize() const;
    void setBaseSize(const QSize &);
    void setBaseSize(int basew, int baseh);

    void setFixedSize(const QSize &);
    void setFixedSize(int w, int h);
    void setFixedWidth(int w);
    void setFixedHeight(int h);

    

    QPoint mapToGlobal(const QPoint &) const;
    QPoint mapFromGlobal(const QPoint &) const;
    QPoint mapToParent(const QPoint &) const;
    QPoint mapFromParent(const QPoint &) const;
    QPoint mapTo(QWidget *, const QPoint &) const;
    QPoint mapFrom(QWidget *, const QPoint &) const;

    QWidget *window() const;
    inline QWidget *topLevelWidget() const { return window(); }

    
    const QPalette &palette() const;
    void setPalette(const QPalette &);

    void setBackgroundRole(QPalette::ColorRole);
    QPalette::ColorRole backgroundRole() const;

    void setForegroundRole(QPalette::ColorRole);
    QPalette::ColorRole foregroundRole() const;

    const QFont &font() const;
    void setFont(const QFont &);
    QFontMetrics fontMetrics() const;
    QFontInfo fontInfo() const;


    QCursor cursor() const;
    void setCursor(const QCursor &);
    void unsetCursor();


    void setMouseTracking(bool enable);
    bool hasMouseTracking() const;
    bool underMouse() const;

    void setMask(const QBitmap &);
    void setMask(const QRegion &);
    QRegion mask() const;
    void clearMask();

    void setWindowTitle(const QString &);
    QString windowTitle() const;
    void setWindowIcon(const QIcon &icon);
    QIcon windowIcon() const;
    void setWindowIconText(const QString &);
    QString windowIconText() const;
    void setWindowRole(const QString &);
    QString windowRole() const;

    void setWindowOpacity(qreal level);
    qreal windowOpacity() const;

    bool isWindowModified() const;

    void setToolTip(const QString &);
    QString toolTip() const;


    void setStatusTip(const QString &);
    QString statusTip() const;


    void setWhatsThis(const QString &);
    QString whatsThis() const;


    QString accessibleName() const;
    void setAccessibleName(const QString &name);
    QString accessibleDescription() const;
    void setAccessibleDescription(const QString &description);


    void setLayoutDirection(Qt::LayoutDirection direction);
    Qt::LayoutDirection layoutDirection() const;
    void unsetLayoutDirection();

    inline bool isRightToLeft() const { return layoutDirection() == Qt::RightToLeft; }
    inline bool isLeftToRight() const { return layoutDirection() == Qt::LeftToRight; }

public :
    inline void setFocus() { setFocus(Qt::OtherFocusReason); }

public:
    bool isActiveWindow() const;
    void activateWindow();
    void clearFocus();

    void setFocus(Qt::FocusReason reason);
    Qt::FocusPolicy focusPolicy() const;
    void setFocusPolicy(Qt::FocusPolicy policy);
    bool hasFocus() const;
    static void setTabOrder(QWidget *, QWidget *);
    void setFocusProxy(QWidget *);
    QWidget *focusProxy() const;
    Qt::ContextMenuPolicy contextMenuPolicy() const;
    void setContextMenuPolicy(Qt::ContextMenuPolicy policy);

    
    void grabMouse();

    void grabMouse(const QCursor &);

    void releaseMouse();
    void grabKeyboard();
    void releaseKeyboard();

    int grabShortcut(const QKeySequence &key, Qt::ShortcutContext context = Qt::WindowShortcut);
    void releaseShortcut(int id);
    void setShortcutEnabled(int id, bool enable = true);

    static QWidget *mouseGrabber();
    static QWidget *keyboardGrabber();

    
    inline bool updatesEnabled() const;
    void setUpdatesEnabled(bool enable);





public :
    void update();
    void repaint();

public:
    inline void update(int x, int y, int w, int h);
    void update(const QRect&);
    void update(const QRegion&);

    void repaint(int x, int y, int w, int h);
    void repaint(const QRect &);
    void repaint(const QRegion &);

public :
    

    virtual void setVisible(bool visible);
    inline void setHidden(bool hidden) { setVisible(!hidden); }
    inline void show() { setVisible(true); }
    inline void hide() { setVisible(false); }
    inline  void setShown(bool shown) { setVisible(shown); }

    void showMinimized();
    void showMaximized();
    void showFullScreen();
    void showNormal();

    bool close();
    void raise();
    void lower();

public:
    void stackUnder(QWidget*);
    void move(int x, int y);
    void move(const QPoint &);
    void resize(int w, int h);
    void resize(const QSize &);
    inline void setGeometry(int x, int y, int w, int h);
    void setGeometry(const QRect &);
    void adjustSize();
    bool isVisible() const;
    bool isVisibleTo(QWidget*) const;
    inline bool isHidden() const;

    bool isMinimized() const;
    bool isMaximized() const;
    bool isFullScreen() const;

    Qt::WindowStates windowState() const;
    void setWindowState(Qt::WindowStates state);
    void overrideWindowState(Qt::WindowStates state);

    virtual QSize sizeHint() const;
    virtual QSize minimumSizeHint() const;

    QSizePolicy sizePolicy() const;
    void setSizePolicy(QSizePolicy);
    inline void setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical);
    virtual int heightForWidth(int) const;

    QRegion visibleRegion() const;

    void setContentsMargins(int left, int top, int right, int bottom);
    void getContentsMargins(int *left, int *top, int *right, int *bottom) const;
    QRect contentsRect() const;

public:
    QLayout *layout() const;
    void setLayout(QLayout *);
    void updateGeometry();

    void setParent(QWidget *parent);
    void setParent(QWidget *parent, Qt::WFlags f);

    void scroll(int dx, int dy);
    void scroll(int dx, int dy, const QRect&);

    

    QWidget *focusWidget() const;
    QWidget *nextInFocusChain() const;

    
    bool acceptDrops() const;
    void setAcceptDrops(bool on);


    
    void addAction(QAction *action);
    void addActions(QList<QAction*> actions);
    void insertAction(QAction *before, QAction *action);
    void insertActions(QAction *before, QList<QAction*> actions);
    void removeAction(QAction *action);
    QList<QAction*> actions() const;


    QWidget *parentWidget() const;

    void setWindowFlags(Qt::WindowFlags type);
    inline Qt::WindowFlags windowFlags() const;
    void overrideWindowFlags(Qt::WindowFlags type);

    inline Qt::WindowType windowType() const;

    static QWidget *find(WId);

    static  QWidgetMapper *wmapper();

    inline QWidget *childAt(int x, int y) const;
    QWidget *childAt(const QPoint &p) const;


    const QX11Info &x11Info() const;
    Qt::HANDLE x11PictureHandle() const;






    Qt::HANDLE handle() const;


    void setAttribute(Qt::WidgetAttribute, bool on = true);
    inline bool testAttribute(Qt::WidgetAttribute) const;

    QPaintEngine *paintEngine() const;

    void ensurePolished() const;

    QInputContext *inputContext();
    void setInputContext(QInputContext *);

    bool isAncestorOf(const QWidget *child) const;






    bool autoFillBackground() const;
    void setAutoFillBackground(bool enabled);

protected:
    void customContextMenuRequested(const QPoint &pos);

protected:
    
    bool event(QEvent *);
    virtual void mousePressEvent(QMouseEvent *);
    virtual void mouseReleaseEvent(QMouseEvent *);
    virtual void mouseDoubleClickEvent(QMouseEvent *);
    virtual void mouseMoveEvent(QMouseEvent *);

    virtual void wheelEvent(QWheelEvent *);

    virtual void keyPressEvent(QKeyEvent *);
    virtual void keyReleaseEvent(QKeyEvent *);
    virtual void focusInEvent(QFocusEvent *);
    virtual void focusOutEvent(QFocusEvent *);
    virtual void enterEvent(QEvent *);
    virtual void leaveEvent(QEvent *);
    virtual void paintEvent(QPaintEvent *);
    virtual void moveEvent(QMoveEvent *);
    virtual void resizeEvent(QResizeEvent *);
    virtual void closeEvent(QCloseEvent *);
    virtual void contextMenuEvent(QContextMenuEvent *);
    virtual void tabletEvent(QTabletEvent *);
    virtual void actionEvent(QActionEvent *);


    virtual void dragEnterEvent(QDragEnterEvent *);
    virtual void dragMoveEvent(QDragMoveEvent *);
    virtual void dragLeaveEvent(QDragLeaveEvent *);
    virtual void dropEvent(QDropEvent *);


    virtual void showEvent(QShowEvent *);
    virtual void hideEvent(QHideEvent *);

#line 568 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
    virtual bool x11Event(XEvent *);





    
    virtual void changeEvent(QEvent *);

    int metric(PaintDeviceMetric) const;

    virtual void inputMethodEvent(QInputMethodEvent *);
public:
    virtual QVariant inputMethodQuery(Qt::InputMethodQuery) const;
protected:
    void resetInputContext();
    void updateMicroFocus();

    void create(WId = 0, bool initializeWindow = true,
                         bool destroyOldWindow = true);
    void destroy(bool destroyWindow = true,
                 bool destroySubWindows = true);

    virtual bool focusNextPrevChild(bool next);
    inline bool focusNextChild() { return focusNextPrevChild(true); }
    inline bool focusPreviousChild() { return focusNextPrevChild(false); }

protected:
    QWidget(QWidgetPrivate &d, QWidget* parent, Qt::WFlags f);
private:

    bool testAttribute_helper(Qt::WidgetAttribute) const;

    friend void qt_syncBackingStore(QWidget *);
    friend void qt_syncBackingStore(QRegion, QWidget *);
    friend void qt_syncBackingStore(QRegion, QWidget *, bool);
    friend class QBackingStoreDevice;
    friend class QWidgetBackingStore;
    friend class QApplication;
    friend class QApplicationPrivate;
    friend class QBaseApplication;
    friend class QPainter;
    friend class QPixmap; 
    friend class QFontMetrics;
    friend class QFontInfo;
    friend class QETWidget;
    friend class QLayout;
    friend class QWidgetItem;
    friend class QGLContext;
    friend class QX11PaintEngine;
    friend class QWin32PaintEngine;
    friend class QShortcutPrivate;

#line 634 "../../include/QtGui/../../src/gui/kernel/qwidget.h"

private:
    QWidget(const QWidget &); QWidget &operator=(const QWidget &);

    QWidgetData *data;


public:
    inline  bool isUpdatesEnabled() const { return updatesEnabled(); }
     QStyle *setStyle(const QString&);
    inline  bool isVisibleToTLW() const;
     QRect visibleRect() const;
    inline  void iconify() { showMinimized(); }
    inline  void constPolish() const { ensurePolished(); }
    inline  void polish() { ensurePolished(); }
    inline  void reparent(QWidget *parent, Qt::WFlags f, const QPoint &p, bool showIt=false)
    { setParent(parent, f); setGeometry(p.x(),p.y(),width(),height()); if (showIt) show(); }
    inline  void reparent(QWidget *parent, const QPoint &p, bool showIt=false)
    { setParent(parent, windowFlags() & ~Qt::WindowType_Mask); setGeometry(p.x(),p.y(),width(),height()); if (showIt) show(); }
    inline  void recreate(QWidget *parent, Qt::WFlags f, const QPoint & p, bool showIt=false)
    { setParent(parent, f); setGeometry(p.x(),p.y(),width(),height()); if (showIt) show(); }
    inline  void setSizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver, bool hfw)
    { QSizePolicy sp(hor, ver); sp.setHeightForWidth(hfw); setSizePolicy(sp);}
    inline  bool hasMouse() const { return testAttribute(Qt::WA_UnderMouse); }

    inline  bool ownCursor() const { return testAttribute(Qt::WA_SetCursor); }

    inline  bool ownFont() const { return testAttribute(Qt::WA_SetFont); }
    inline  void unsetFont() { setFont(QFont()); }
    inline  bool ownPalette() const { return testAttribute(Qt::WA_SetPalette); }
    inline  void unsetPalette() { setPalette(QPalette()); }
    Qt::BackgroundMode  backgroundMode() const;
    void  setBackgroundMode(Qt::BackgroundMode, Qt::BackgroundMode = Qt::PaletteBackground);
    const  QColor &eraseColor() const;
    void  setEraseColor(const QColor &);
    const  QColor &foregroundColor() const;
    const  QPixmap *erasePixmap() const;
    void  setErasePixmap(const QPixmap &);
    const  QColor &paletteForegroundColor() const;
    void  setPaletteForegroundColor(const QColor &);
    const  QColor &paletteBackgroundColor() const;
    void  setPaletteBackgroundColor(const QColor &);
    const  QPixmap *paletteBackgroundPixmap() const;
    void  setPaletteBackgroundPixmap(const QPixmap &);
    const  QBrush& backgroundBrush() const;
    const  QColor &backgroundColor() const;
    const  QPixmap *backgroundPixmap() const;
    void  setBackgroundPixmap(const QPixmap &);
     void setBackgroundColor(const QColor &);
     QColorGroup colorGroup() const;
     QWidget *parentWidget(bool sameWindow) const;
    inline  void setKeyCompression(bool b) { setAttribute(Qt::WA_KeyCompression, b); }
    inline  void setFont(const QFont &f, bool) { setFont(f); }
    inline  void setPalette(const QPalette &p, bool) { setPalette(p); }
    enum BackgroundOrigin { WidgetOrigin, ParentOrigin, WindowOrigin, AncestorOrigin };
    inline  void setBackgroundOrigin(BackgroundOrigin){};
    inline  BackgroundOrigin backgroundOrigin() const { return WindowOrigin; }
    inline  QPoint backgroundOffset() const { return QPoint(); }
    inline  void repaint(bool) { repaint(); }
    inline  void repaint(int x, int y, int w, int h, bool) { repaint(x,y,w,h); }
    inline  void repaint(const QRect &r, bool) { repaint(r); }
    inline  void repaint(const QRegion &rgn, bool) { repaint(rgn); }
     void erase();
    inline  void erase(int x, int y, int w, int h) { erase_helper(x, y, w, h); }
     void erase(const QRect &);
     void erase(const QRegion &);
     void drawText(const QPoint &p, const QString &s)
    { drawText_helper(p.x(), p.y(), s); }
    inline  void drawText(int x, int y, const QString &s)
    { drawText_helper(x, y, s); }
     bool close(bool);
    inline  QWidget *childAt(int x, int y, bool includeThis) const
    {
        QWidget *w = childAt(x, y);
        return w ? w : ((includeThis && rect().contains(x,y))?const_cast<QWidget*>(this):0);
    }
    inline  QWidget *childAt(const QPoint &p, bool includeThis) const
    {
        QWidget *w = childAt(p);
        return w ? w : ((includeThis && rect().contains(p))?const_cast<QWidget*>(this):0);
    }
    inline  void setCaption(const QString &c)   { setWindowTitle(c); }
     void setIcon(const QPixmap &i);
    inline  void setIconText(const QString &it) { setWindowIconText(it); }
    inline  QString caption() const             { return windowTitle(); }
     const QPixmap *icon() const;
    inline  QString iconText() const            { return windowIconText(); }
    inline  void setInputMethodEnabled(bool b) { setAttribute(Qt::WA_InputMethodEnabled, b); }
    inline  bool isInputMethodEnabled() const { return testAttribute(Qt::WA_InputMethodEnabled); }
    inline  void setActiveWindow() { activateWindow(); }
    inline  bool isShown() const { return !isHidden(); }
    inline  bool isDialog() const { return windowType() == Qt::Dialog; }
    inline  bool isPopup() const { return windowType() == Qt::Popup; }
    inline  bool isDesktop() const { return windowType() == Qt::Desktop; }


private:
    void drawText_helper(int x, int y, const QString &);
    void erase_helper(int x, int y, int w, int h);


protected:
    virtual void styleChange(QStyle&); 
    virtual void enabledChange(bool);  
    virtual void paletteChange(const QPalette &);  
    virtual void fontChange(const QFont &); 
    virtual void windowActivationChange(bool);  
    virtual void languageChange();  
};

#line 751 "../../include/QtGui/../../src/gui/kernel/qwidget.h"
template <> inline QWidget *qobject_cast<QWidget*>(QObject *o)
{
    if (!o || !o->isWidgetType()) return 0;
    return static_cast<QWidget*>(o);
}
template <> inline const QWidget *qobject_cast<const QWidget*>(const QObject *o)
{
    if (!o || !o->isWidgetType()) return 0;
    return static_cast<const QWidget*>(o);
}


inline QWidget *QWidget::childAt(int ax, int ay) const
{ return childAt(QPoint(ax, ay)); }

inline Qt::WindowType QWidget::windowType() const
{ return static_cast<Qt::WindowType>(int(data->window_flags & Qt::WindowType_Mask)); }
inline Qt::WindowFlags QWidget::windowFlags() const
{ return data->window_flags; }

inline WId QWidget::winId() const
{ return data->winid; }

inline bool QWidget::isTopLevel() const
{ return (windowType() & Qt::Window); }

inline bool QWidget::isWindow() const
{ return (windowType() & Qt::Window); }

inline bool QWidget::isEnabled() const
{ return !testAttribute(Qt::WA_Disabled); }

inline bool QWidget::isModal() const
{ return data->window_modality != Qt::NonModal; }

inline bool QWidget::isEnabledToTLW() const
{ return isEnabled(); }

inline int QWidget::minimumWidth() const
{ return minimumSize().width(); }

inline int QWidget::minimumHeight() const
{ return minimumSize().height(); }

inline int QWidget::maximumWidth() const
{ return maximumSize().width(); }

inline int QWidget::maximumHeight() const
{ return maximumSize().height(); }

inline void QWidget::setMinimumSize(const QSize &s)
{ setMinimumSize(s.width(),s.height()); }

inline void QWidget::setMaximumSize(const QSize &s)
{ setMaximumSize(s.width(),s.height()); }

inline void QWidget::setSizeIncrement(const QSize &s)
{ setSizeIncrement(s.width(),s.height()); }

inline void QWidget::setBaseSize(const QSize &s)
{ setBaseSize(s.width(),s.height()); }

inline const QFont &QWidget::font() const
{ return data->fnt; }

inline QFontMetrics QWidget::fontMetrics() const
{ return QFontMetrics(data->fnt); }

inline QFontInfo QWidget::fontInfo() const
{ return QFontInfo(data->fnt); }

inline void QWidget::setMouseTracking(bool enable)
{ setAttribute(Qt::WA_MouseTracking, enable); }

inline bool QWidget::hasMouseTracking() const
{ return testAttribute(Qt::WA_MouseTracking); }

inline bool QWidget::underMouse() const
{ return testAttribute(Qt::WA_UnderMouse); }

inline bool QWidget::updatesEnabled() const
{ return !testAttribute(Qt::WA_UpdatesDisabled); }

inline void QWidget::update(int ax, int ay, int aw, int ah)
{ update(QRect(ax, ay, aw, ah)); }

inline bool QWidget::isVisible() const
{ return testAttribute(Qt::WA_WState_Visible); }

inline bool QWidget::isHidden() const
{ return testAttribute(Qt::WA_WState_Hidden); }

inline void QWidget::move(int ax, int ay)
{ move(QPoint(ax, ay)); }

inline void QWidget::resize(int w, int h)
{ resize(QSize(w, h)); }

inline void QWidget::setGeometry(int ax, int ay, int aw, int ah)
{ setGeometry(QRect(ax, ay, aw, ah)); }

inline QRect QWidget::rect() const
{ return QRect(0,0,data->crect.width(),data->crect.height()); }

inline const QRect &QWidget::geometry() const
{ return data->crect; }

inline QSize QWidget::size() const
{ return data->crect.size(); }

inline int QWidget::width() const
{ return data->crect.width(); }

inline int QWidget::height() const
{ return data->crect.height(); }

inline QWidget *QWidget::parentWidget() const
{ return static_cast<QWidget *>(QObject::parent()); }

inline void QWidget::setSizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver)
{ setSizePolicy(QSizePolicy(hor, ver)); }

inline bool QWidget::testAttribute(Qt::WidgetAttribute attribute) const
{
    if (attribute < int(8*sizeof(uint)))
        return data->widget_attributes & (1<<attribute);
    return testAttribute_helper(attribute);
}


inline bool QWidget::isVisibleToTLW() const
{ return isVisible(); }
inline QWidget *QWidget::parentWidget(bool sameWindow) const
{
    if (sameWindow && isWindow())
        return 0;
    return static_cast<QWidget *>(QObject::parent());
}
inline QColorGroup QWidget::colorGroup() const
{ return QColorGroup(palette()); }
inline void QWidget::setPaletteForegroundColor(const QColor &c)
{ QPalette p = palette(); p.setColor(foregroundRole(), c); setPalette(p); }
inline const QBrush& QWidget::backgroundBrush() const { return palette().brush(backgroundRole()); }
inline void QWidget::setBackgroundPixmap(const QPixmap &pm)
{ QPalette p = palette(); p.setBrush(backgroundRole(), QBrush(pm)); setPalette(p); }
inline const QPixmap *QWidget::backgroundPixmap() const { return 0; }
inline void QWidget::setBackgroundColor(const QColor &c)
{ QPalette p = palette(); p.setColor(backgroundRole(), c); setPalette(p); }
inline const QColor & QWidget::backgroundColor() const { return palette().color(backgroundRole()); }
inline const QColor &QWidget::foregroundColor() const { return palette().color(foregroundRole());}
inline const QColor &QWidget::eraseColor() const { return palette().color(backgroundRole()); }
inline void QWidget::setEraseColor(const QColor &c)
{ QPalette p = palette(); p.setColor(backgroundRole(), c); setPalette(p); }
inline const QPixmap *QWidget::erasePixmap() const { return 0; }
inline void QWidget::setErasePixmap(const QPixmap &pm)
{ QPalette p = palette(); p.setBrush(backgroundRole(), QBrush(pm)); setPalette(p); }
inline const QColor &QWidget::paletteForegroundColor() const { return palette().color(foregroundRole());}
inline const QColor &QWidget::paletteBackgroundColor() const { return palette().color(backgroundRole()); }
inline void QWidget::setPaletteBackgroundColor(const QColor &c)
{ QPalette p = palette(); p.setColor(backgroundRole(), c); setPalette(p); }
inline const QPixmap *QWidget::paletteBackgroundPixmap() const
{ return 0; }
inline void QWidget::setPaletteBackgroundPixmap(const QPixmap &pm)
{ QPalette p = palette(); p.setBrush(backgroundRole(), QBrush(pm)); setPalette(p); }
inline  void QWidget::erase() { erase_helper(0, 0, data->crect.width(), data->crect.height()); }
inline  void QWidget::erase(const QRect &r) { erase_helper(r.x(), r.y(), r.width(), r.height()); }






#line 2 "../../include/QtGui/qwidget.h"
#line 35 "../../include/QtGui/../../src/gui/kernel/qapplication.h"
#line 1 "../../include/QtGui/qpalette.h"
#line 36 "../../include/QtGui/../../src/gui/kernel/qapplication.h"








typedef QtValidLicenseForGuiModule QtGuiModule;

class QSessionManager;
class QDesktopWidget;
class QStyle;
class QEventLoop;
class QIcon;
template <typename T> class QList;
class QInputContext;




class QApplication;
class QApplicationPrivate;


class  QApplication : public QCoreApplication
{
    public: static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject . tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject . trUtf8(s, c); } virtual int qt_metacall(QMetaObject::Call, int, void * *); private:
    
    
    
    
    

    

    
    
    
    

public:
    QApplication(int &argc, char **argv);
    QApplication(int &argc, char **argv, bool GUIenabled);
    enum Type { Tty, GuiClient, GuiServer };
    QApplication(int &argc, char **argv, Type);

    QApplication(Display* dpy, Qt::HANDLE visual = 0, Qt::HANDLE cmap = 0);
    QApplication(Display *dpy, int &argc, char **argv, Qt::HANDLE visual = 0, Qt::HANDLE cmap= 0);

    virtual ~QApplication();

    static Type type();

    static QStyle *style();
    static void setStyle(QStyle*);
    static QStyle *setStyle(const QString&);
    enum ColorSpec { NormalColor=0, CustomColor=1, ManyColor=2 };
    static int colorSpec();
    static void setColorSpec(int);


    static QCursor *overrideCursor();
    static void setOverrideCursor(const QCursor &);
    static void changeOverrideCursor(const QCursor &);
    static void restoreOverrideCursor();

    static QPalette palette();
    static QPalette palette(const QWidget *);
    static QPalette palette(const char *className);
    static void setPalette(const QPalette &, const char* className = 0);
    static QFont font(const QWidget* = 0);
    static void setFont(const QFont &, const char* className = 0);
    static QFontMetrics fontMetrics();

    static void setWindowIcon(const QIcon &icon);
    static QIcon windowIcon();



    static  QWidget *mainWidget();
    static  void setMainWidget(QWidget *);


    static QWidgetList allWidgets();
    static QWidgetList topLevelWidgets();

    static QDesktopWidget *desktop();

    static QWidget *activePopupWidget();
    static QWidget *activeModalWidget();

    static QClipboard *clipboard();

    static QWidget *focusWidget();

    static QWidget *activeWindow();
    static void setActiveWindow(QWidget* act);

    static QWidget *widgetAt(const QPoint &p);
    static inline QWidget *widgetAt(int x, int y) { return widgetAt(QPoint(x, y)); }
    static QWidget *topLevelAt(const QPoint &p);
    static inline QWidget *topLevelAt(int x, int y)  { return topLevelAt(QPoint(x, y)); }

    static void syncX();
    static void beep();

    static Qt::KeyboardModifiers keyboardModifiers();
    static Qt::MouseButtons mouseButtons();

    static void setDesktopSettingsAware(bool);
    static bool desktopSettingsAware();

    static void setCursorFlashTime(int);
    static int cursorFlashTime();

    static void setDoubleClickInterval(int);
    static int doubleClickInterval();

    static void setKeyboardInputInterval(int);
    static int keyboardInputInterval();


    static void setWheelScrollLines(int);
    static int wheelScrollLines();

    static void setGlobalStrut(const QSize &);
    static QSize globalStrut();

    static void setStartDragTime(int ms);
    static int startDragTime();
    static void setStartDragDistance(int l);
    static int startDragDistance();

    static void setLayoutDirection(Qt::LayoutDirection direction);
    static Qt::LayoutDirection layoutDirection();

    static inline bool isRightToLeft() { return layoutDirection() == Qt::RightToLeft; }
    static inline bool isLeftToRight() { return layoutDirection() == Qt::LeftToRight; }

    static bool isEffectEnabled(Qt::UIEffect);
    static void setEffectEnabled(Qt::UIEffect, bool enable = true);





    virtual bool x11EventFilter(XEvent *);
    virtual int x11ClientMessage(QWidget*, XEvent*, bool passive_only);
    int x11ProcessEvent(XEvent*);
#line 197 "../../include/QtGui/../../src/gui/kernel/qapplication.h"








    
    bool isSessionRestored() const;
    QString sessionId() const;
    QString sessionKey() const;
    virtual void commitData(QSessionManager& sm);
    virtual void saveState(QSessionManager& sm);

    void setInputContext(QInputContext *);
    QInputContext *inputContext() const;

    static int exec();
    bool notify(QObject *, QEvent *);


    static void setQuitOnLastWindowClosed(bool quit);
    static bool quitOnLastWindowClosed();






protected:
    void lastWindowClosed();
    void focusChanged(QWidget *old, QWidget *now);

public :
    static void closeAllWindows();
    static void aboutQt();

protected:



    bool event(QEvent *);
    bool compressEvent(QEvent *, QObject *receiver, QPostEventList *);


public:
    static inline  void setReverseLayout(bool b) { setLayoutDirection(b?Qt::RightToLeft:Qt::LeftToRight); }
    static inline bool  reverseLayout() { return layoutDirection() == Qt::RightToLeft; }
    static  Qt::Alignment horizontalAlignment(Qt::Alignment align);
    typedef int ColorMode;
    enum { NormalColors = NormalColor, CustomColors = CustomColor };
    static inline  ColorMode colorMode() { return static_cast<ColorMode>(colorSpec()); }
    static inline  void setColorMode(ColorMode mode) { setColorSpec(int(mode)); }
#line 257 "../../include/QtGui/../../src/gui/kernel/qapplication.h"
    inline static   void setOverrideCursor(const QCursor &cursor, bool replace)
        { if (replace) changeOverrideCursor(cursor); else setOverrideCursor(cursor); }
    inline static  bool hasGlobalMouseTracking() {return true;}
    inline static  void setGlobalMouseTracking(bool) {};
    inline static  void flushX() { flush(); }
    static inline  void setWinStyleHighlightColor(const QColor &c) {
        QPalette p(palette());
        p.setColor(QPalette::Highlight, c);
        setPalette(p);
    }
    static inline  const QColor &winStyleHighlightColor()
        { return palette().color(QPalette::Active, QPalette::Highlight); }
    static inline  void setPalette(const QPalette &pal, bool, const char* className = 0)
        { setPalette(pal, className); };
    static inline  void setFont(const QFont &font, bool, const char* className = 0)
        { setFont(font, className); }

    static inline  QWidget *widgetAt(int x, int y, bool child)
        { QWidget *w = widgetAt(x, y); return child ? w : (w ? w->window() : 0); }
    static inline  QWidget *widgetAt(const QPoint &p, bool child)
        { QWidget *w = widgetAt(p); return child ? w : (w ? w->window() : 0); }


private:
    QApplication(const QApplication &); QApplication &operator=(const QApplication &);
    inline QApplicationPrivate* d_func() { return reinterpret_cast<QApplicationPrivate * >(d_ptr); } inline const QApplicationPrivate* d_func() const { return reinterpret_cast<const QApplicationPrivate * >(d_ptr); } friend class QApplicationPrivate;

    friend class QWidget;
    friend class QWidgetPrivate;
    friend class QETWidget;
    friend class Q3AccelManager;
    friend class QTranslator;

    friend class QShortcut;

    friend class QAction;






    
};



#line 2 "../../include/QtGui/qapplication.h"
#line 37 "text/qtextengine.cpp"










#line 58 "text/qtextengine.cpp"

struct QBidiStatus {
    QBidiStatus() {
        eor = QChar::DirON;
        lastStrong = QChar::DirON;
        last = QChar:: DirON;
        dir = QChar::DirON;
    }
    QChar::Direction eor;
    QChar::Direction lastStrong;
    QChar::Direction last;
    QChar::Direction dir;
};


enum { MaxBidiLevel = 61 };

struct QBidiControl {
    inline QBidiControl(bool rtl)
        : cCtx(0), base(rtl), override(false), level(rtl) {}

    inline void embed(bool rtl, bool o = false) {
        uchar plus2 = 0;
        if((level%2 != 0) == rtl ) {
            level++;
            plus2 = 2;
        }
        level++;
        if (level <= MaxBidiLevel) {
            override = o;
            unsigned char control = (plus2 + (override ? 1 : 0)) << (cCtx % 4)*2;
            unsigned char mask = ~(0x3 << (cCtx % 4)*2);
            ctx[cCtx>>2] &= mask;
            ctx[cCtx>>2] |= control;
            cCtx++;
        }
    }
    inline bool canPop() const { return cCtx != 0; }
    inline void pdf() {
        do {if(!(cCtx))qt_assert("cCtx","text/qtextengine.cpp",97);} while (0);
        (void) --cCtx;
        unsigned char control = (ctx[cCtx>>2] >> ((cCtx % 4)*2)) & 0x3;
        override = control & 0x1;
        level--;
        if (control & 0x2)
            level--;
    }

    inline QChar::Direction basicDirection() const {
        return (base ? QChar::DirR : QChar:: DirL);
    }
    inline uchar baseLevel() const {
        return base;
    }
    inline QChar::Direction direction() const {
        return ((level%2) ? QChar::DirR : QChar:: DirL);
    }

    unsigned char ctx[(MaxBidiLevel+3)/4];
    unsigned char cCtx : 6;
    unsigned char base : 1;
    unsigned char override : 1;
    unsigned char unused : 2;
    unsigned char level : 6;
};

static void qAppendItems(QTextEngine *engine, int &start, int &stop, QBidiControl &control, QChar::Direction dir)
{
    QScriptItemArray &items = engine->layoutData->items;
    const QChar *text = engine->layoutData->string.unicode();

    if (start > stop) {
        

        return;
    }

    int level = control.level;

    if(dir != QChar::DirON && !control.override) {
        
        if(level % 2) {
            if(dir == QChar::DirL || dir == QChar::DirAN || dir == QChar::DirEN)
                level++;
        } else {
            if(dir == QChar::DirR)
                level++;
            else if(dir == QChar::DirAN || dir == QChar::DirEN)
                level += 2;
        }
    }




    int script = -1;
    QScriptItem item;
    item.position = start;
    item.analysis.script = script;
    item.analysis.bidiLevel = level;
    item.analysis.override = control.override;
    item.analysis.reserved = 0;

    for (int i = start; i <= stop; i++) {
        unsigned short uc = text[i].unicode();
        int s = QUnicodeTables::script(text[i]);
        if (uc == QChar::ObjectReplacementCharacter || uc == QChar::LineSeparator) {
            item.analysis.bidiLevel = level % 2 ? level-1 : level;
            item.analysis.script = QUnicodeTables::Common;
            item.isObject = true;
            s = -1;
        } else if (uc == 9) {
            item.analysis.script = QUnicodeTables::Common;
            item.isSpace = true;
            item.isTab = true;
            item.analysis.bidiLevel = control.baseLevel();
            s = -1;
        } else if (s != script && (s != QUnicodeTables::Inherited || script == -1)) {
            item.analysis.script = s == QUnicodeTables::Inherited ? QUnicodeTables::Common : s;
            item.analysis.bidiLevel = level;
        } else {
            if (i - start < 32000)
                continue;
            start = i;
        }

        item.position = i;
        items.append(item);
        script = s;
        item.isSpace = item.isTab = item.isObject = false;
    }
    ++stop;
    start = stop;
}

typedef void (* fAppendItems)(QTextEngine *, int &start, int &stop, QBidiControl &control, QChar::Direction dir);
static fAppendItems appendItems = qAppendItems;


static bool bidiItemize(QTextEngine *engine, bool rightToLeft)
{



    QBidiControl control(rightToLeft);

    bool hasBidi = rightToLeft;

    int sor = 0;
    int eor = -1;

    
    bool first = true;

    int length = engine->layoutData->string.length();

    if (!length)
        return hasBidi;

    const QChar *unicode = engine->layoutData->string.unicode();
    int current = 0;

    QChar::Direction dir = rightToLeft ? QChar::DirR : QChar::DirL;
    QBidiStatus status;
    QChar::Direction sdir = direction(*unicode);
    if (sdir != QChar::DirL && sdir != QChar::DirR && sdir != QChar::DirEN && sdir != QChar::DirAN)
	sdir = QChar::DirON;
    else
        dir = QChar::DirON;
    status.eor = sdir;
    status.lastStrong = rightToLeft ? QChar::DirR : QChar::DirL;
    status.last = status.lastStrong;
    status.dir = sdir;



    while (current <= length) {

        QChar::Direction dirCurrent;
        if (current == (int)length)
            dirCurrent = control.basicDirection();
        else
            dirCurrent = direction(unicode[current]);

#line 250 "text/qtextengine.cpp"

        switch(dirCurrent) {

            
        case QChar::DirRLE:
        case QChar::DirRLO:
        case QChar::DirLRE:
        case QChar::DirLRO:
            {
                bool rtl = (dirCurrent == QChar::DirRLE || dirCurrent == QChar::DirRLO);
                hasBidi |= rtl;
                bool override = (dirCurrent == QChar::DirLRO || dirCurrent == QChar::DirRLO);

                uchar level = control.level+1;
                if ((level%2 != 0) == rtl) ++level;
                if(level < MaxBidiLevel) {
                    eor = current-1;
                    appendItems(engine, sor, eor, control, dir);
                    eor = current;
                    control.embed(rtl, override);
                    QChar::Direction edir = (rtl ? QChar::DirR : QChar::DirL);
                    dir = status.eor = edir;
                    status.lastStrong = edir;
                }
                break;
            }
        case QChar::DirPDF:
            {
                if (control.canPop()) {
                    if (dir != control.direction()) {
                        eor = current-1;
                        appendItems(engine, sor, eor, control, dir);
                        dir = control.direction();
                    }
                    eor = current;
                    appendItems(engine, sor, eor, control, dir);
                    control.pdf();
                    dir = QChar::DirON; status.eor = QChar::DirON;
                    status.last = control.direction();
                    if (control.override)
                        dir = control.direction();
                    else
                        dir = QChar::DirON;
                    status.lastStrong = control.direction();
                }
                break;
            }

            
        case QChar::DirL:
            if(dir == QChar::DirON)
                dir = QChar::DirL;
            switch(status.last)
                {
                case QChar::DirL:
                    eor = current; status.eor = QChar::DirL; break;
                case QChar::DirR:
                case QChar::DirAL:
                case QChar::DirEN:
                case QChar::DirAN:
                    if (!first) {
                        appendItems(engine, sor, eor, control, dir);
                        dir = eor < length ? direction(unicode[eor]) : control.basicDirection();
                        status.eor = dir;
                    } else {
                        eor = current; status.eor = dir;
                    }
                    break;
                case QChar::DirES:
                case QChar::DirET:
                case QChar::DirCS:
                case QChar::DirBN:
                case QChar::DirB:
                case QChar::DirS:
                case QChar::DirWS:
                case QChar::DirON:
                    if(dir != QChar::DirL) {
                        
                        if(control.direction() == QChar::DirR) {
                            if(status.eor != QChar::DirR) {
                                
                                appendItems(engine, sor, eor, control, dir);
                                status.eor = QChar::DirON;
                                dir = QChar::DirR;
                            }
                            eor = current - 1;
                            appendItems(engine, sor, eor, control, dir);
                            dir = eor < length ? direction(unicode[eor]) : control.basicDirection();
                            status.eor = dir;
                        } else {
                            if(status.eor != QChar::DirL) {
                                appendItems(engine, sor, eor, control, dir);
                                status.eor = QChar::DirON;
                                dir = QChar::DirL;
                            } else {
                                eor = current; status.eor = QChar::DirL; break;
                            }
                        }
                    } else {
                        eor = current; status.eor = QChar::DirL;
                    }
                default:
                    break;
                }
            status.lastStrong = QChar::DirL;
            break;
        case QChar::DirAL:
        case QChar::DirR:
            hasBidi = true;
            if(dir == QChar::DirON) dir = QChar::DirR;
            switch(status.last)
                {
                case QChar::DirL:
                case QChar::DirEN:
                case QChar::DirAN:
                    if (!first)
                        appendItems(engine, sor, eor, control, dir);
                    
                case QChar::DirR:
                case QChar::DirAL:
                    dir = QChar::DirR; eor = current; status.eor = QChar::DirR; break;
                case QChar::DirES:
                case QChar::DirET:
                case QChar::DirCS:
                case QChar::DirBN:
                case QChar::DirB:
                case QChar::DirS:
                case QChar::DirWS:
                case QChar::DirON:
                    if(status.eor != QChar::DirR && status.eor != QChar::DirAL) {
                        
                        if(control.direction() == QChar::DirR
                           || status.lastStrong == QChar::DirR || status.lastStrong == QChar::DirAL) {
                            appendItems(engine, sor, eor, control, dir);
                            dir = QChar::DirR; status.eor = QChar::DirON;
                            eor = current;
                        } else {
                            eor = current - 1;
                            appendItems(engine, sor, eor, control, dir);
                            dir = QChar::DirR; status.eor = QChar::DirON;
                        }
                    } else {
                        eor = current; status.eor = QChar::DirR;
                    }
                default:
                    break;
                }
            status.lastStrong = dirCurrent;
            break;

            

        case QChar::DirNSM:
            if (eor == current-1)
                eor = current;
            break;
        case QChar::DirEN:
            
            if(status.lastStrong != QChar::DirAL) {
                if(dir == QChar::DirON) {
                    if(status.lastStrong == QChar::DirL)
                        dir = QChar::DirL;
                    else
                        dir = QChar::DirEN;
                }
                switch(status.last)
                    {
                    case QChar::DirET:
                        if (status.lastStrong == QChar::DirR || status.lastStrong == QChar::DirAL) {
                            appendItems(engine, sor, eor, control, dir);
                            status.eor = QChar::DirON;
                            dir = QChar::DirAN;
                        }
                        
                    case QChar::DirEN:
                    case QChar::DirL:
                        eor = current;
                        status.eor = dirCurrent;
                        break;
                    case QChar::DirR:
                    case QChar::DirAL:
                    case QChar::DirAN:
                        if (!first)
                            appendItems(engine, sor, eor, control, dir);
                        status.eor = QChar::DirEN;
                        dir = QChar::DirAN; break;
                    case QChar::DirES:
                    case QChar::DirCS:
                        if(status.eor == QChar::DirEN || dir == QChar::DirAN) {
                            eor = current; break;
                        }
                    case QChar::DirBN:
                    case QChar::DirB:
                    case QChar::DirS:
                    case QChar::DirWS:
                    case QChar::DirON:
                        if(status.eor == QChar::DirR) {
                            
                            eor = current - 1;
                            appendItems(engine, sor, eor, control, dir);
                            dir = QChar::DirON; status.eor = QChar::DirEN;
                            dir = QChar::DirAN;
                        }
                        else if(status.eor == QChar::DirL ||
                                 (status.eor == QChar::DirEN && status.lastStrong == QChar::DirL)) {
                            eor = current; status.eor = dirCurrent;
                        } else {
                            
                            if(dir != QChar::DirL) {
                                appendItems(engine, sor, eor, control, dir);
                                dir = QChar::DirON; status.eor = QChar::DirON;
                                eor = current - 1;
                                dir = QChar::DirR;
                                appendItems(engine, sor, eor, control, dir);
                                dir = QChar::DirON; status.eor = QChar::DirON;
                                dir = QChar::DirAN;
                            } else {
                                eor = current; status.eor = dirCurrent;
                            }
                        }
                    default:
                        break;
                    }
                break;
            }
        case QChar::DirAN:
            hasBidi = true;
            dirCurrent = QChar::DirAN;
            if(dir == QChar::DirON) dir = QChar::DirAN;
            switch(status.last)
                {
                case QChar::DirL:
                case QChar::DirAN:
                    eor = current; status.eor = QChar::DirAN; break;
                case QChar::DirR:
                case QChar::DirAL:
                case QChar::DirEN:
                    if (!first)
                        appendItems(engine, sor, eor, control, dir);
                    dir = QChar::DirON; status.eor = QChar::DirAN;
                    break;
                case QChar::DirCS:
                    if(status.eor == QChar::DirAN) {
                        eor = current; break;
                    }
                case QChar::DirES:
                case QChar::DirET:
                case QChar::DirBN:
                case QChar::DirB:
                case QChar::DirS:
                case QChar::DirWS:
                case QChar::DirON:
                    if(status.eor == QChar::DirR) {
                        
                        eor = current - 1;
                        appendItems(engine, sor, eor, control, dir);
                        status.eor = QChar::DirAN;
                        dir = QChar::DirAN;
                    } else if(status.eor == QChar::DirL ||
                               (status.eor == QChar::DirEN && status.lastStrong == QChar::DirL)) {
                        eor = current; status.eor = dirCurrent;
                    } else {
                        
                        if(dir != QChar::DirL) {
                            appendItems(engine, sor, eor, control, dir);
                            status.eor = QChar::DirON;
                            eor = current - 1;
                            dir = QChar::DirR;
                            appendItems(engine, sor, eor, control, dir);
                            status.eor = QChar::DirAN;
                            dir = QChar::DirAN;
                        } else {
                            eor = current; status.eor = dirCurrent;
                        }
                    }
                default:
                    break;
                }
            break;
        case QChar::DirES:
        case QChar::DirCS:
            break;
        case QChar::DirET:
            if(status.last == QChar::DirEN) {
                dirCurrent = QChar::DirEN;
                eor = current; status.eor = dirCurrent;
            }
            break;

            
        case QChar::DirBN:
            break;
            
        case QChar::DirB:
            
            break;
        case QChar::DirS:
            
            break;
        case QChar::DirWS:
        case QChar::DirON:
            break;
        default:
            break;
        }

        

        if(current >= (int)length) break;

        
        switch(dirCurrent) {
        case QChar::DirET:
        case QChar::DirES:
        case QChar::DirCS:
        case QChar::DirS:
        case QChar::DirWS:
        case QChar::DirON:
            switch(status.last)
            {
            case QChar::DirL:
            case QChar::DirR:
            case QChar::DirAL:
            case QChar::DirEN:
            case QChar::DirAN:
                status.last = dirCurrent;
                break;
            default:
                status.last = QChar::DirON;
            }
            break;
        case QChar::DirNSM:
        case QChar::DirBN:
            
            break;
        case QChar::DirLRO:
        case QChar::DirLRE:
            status.last = QChar::DirL;
            break;
        case QChar::DirRLO:
        case QChar::DirRLE:
            status.last = QChar::DirR;
            break;
        case QChar::DirEN:
            if (status.last == QChar::DirL) {
                status.last = QChar::DirL;
                break;
            }
            
        default:
            status.last = dirCurrent;
        }

        first = false;
        ++current;
    }




    eor = current - 1; 

    if (sor <= eor)
        appendItems(engine, sor, eor, control, dir);

    return hasBidi;
}

void QTextEngine::bidiReorder(int numItems, const quint8 *levels, int *visualOrder)
{

    
    uchar levelLow = 128;
    uchar levelHigh = 0;
    int i = 0;
    while (i < numItems) {
        
        if (levels[i] > levelHigh)
            levelHigh = levels[i];
        if (levels[i] < levelLow)
            levelLow = levels[i];
        i++;
    }

    
    
    

    
    if(!(levelLow%2)) levelLow++;





    int count = numItems - 1;
    for (i = 0; i < numItems; i++)
        visualOrder[i] = i;

    while(levelHigh >= levelLow) {
        int i = 0;
        while (i < count) {
            while(i < count && levels[i] < levelHigh) i++;
            int start = i;
            while(i <= count && levels[i] >= levelHigh) i++;
            int end = i-1;

            if(start != end) {
                
                for(int j = 0; j < (end-start+1)/2; j++) {
                    int tmp = visualOrder[start+j];
                    visualOrder[start+j] = visualOrder[end-j];
                    visualOrder[end-j] = tmp;
                }
            }
            i++;
        }
        levelHigh--;
    }






}





































 

enum break_action {
    Dbk, 
    Ibk, 
    Pbk 
};



static const quint8 breakTable[QUnicodeTables::LineBreak_CM+1][QUnicodeTables::LineBreak_CM+1] =
{
    
    { Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk, Pbk }, 
    { Dbk, Pbk, Ibk, Pbk, Pbk, Pbk, Pbk, Pbk, Ibk, Ibk, Dbk, Ibk, Dbk, Dbk, Ibk, Ibk, Pbk, Pbk, Pbk, Pbk }, 
    { Pbk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Pbk, Pbk }, 
    { Ibk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Pbk, Pbk }, 
    { Dbk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Ibk, Ibk, Dbk, Dbk, Pbk, Ibk }, 
    { Dbk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Dbk, Ibk, Ibk, Ibk, Dbk, Dbk, Ibk, Ibk, Dbk, Dbk, Pbk, Ibk }, 
    { Ibk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Ibk, Ibk, Ibk, Ibk, Dbk, Dbk, Ibk, Ibk, Dbk, Dbk, Pbk, Ibk }, 
    { Dbk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Dbk, Dbk, Ibk, Ibk, Dbk, Dbk, Ibk, Ibk, Dbk, Dbk, Pbk, Ibk }, 
    { Ibk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Ibk, Ibk, Ibk, Ibk, Ibk, Dbk, Ibk, Ibk, Dbk, Dbk, Pbk, Pbk }, 
    { Ibk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Ibk, Ibk, Ibk, Ibk, Dbk, Dbk, Ibk, Ibk, Dbk, Dbk, Pbk, Ibk }, 
    { Dbk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Ibk, Ibk, Ibk, Ibk, Dbk, Ibk, Ibk, Ibk, Dbk, Dbk, Pbk, Pbk }, 
    { Ibk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Ibk, Ibk, Ibk, Ibk, Dbk, Ibk, Ibk, Ibk, Dbk, Dbk, Pbk, Pbk }, 
    { Dbk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Dbk, Ibk, Dbk, Dbk, Dbk, Ibk, Ibk, Ibk, Dbk, Dbk, Pbk, Ibk }, 
    { Dbk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Dbk, Dbk, Dbk, Dbk, Dbk, Ibk, Ibk, Ibk, Dbk, Dbk, Pbk, Ibk }, 
    { Ibk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Ibk, Ibk, Ibk, Ibk, Dbk, Dbk, Ibk, Ibk, Dbk, Dbk, Pbk, Ibk }, 
    { Dbk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Ibk, Ibk, Dbk, Dbk, Pbk, Ibk }, 
    { Ibk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Ibk, Pbk, Ibk }, 
    { Dbk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Ibk, Ibk, Dbk, Pbk, Pbk, Ibk }, 
    { Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Dbk, Pbk, Ibk }, 
    { Dbk, Pbk, Ibk, Pbk, Ibk, Pbk, Pbk, Pbk, Dbk, Ibk, Dbk, Dbk, Dbk, Ibk, Ibk, Ibk, Dbk, Dbk, Pbk, Pbk }  
};


static void calcLineBreaks(const QString &str, QCharAttributes *charAttributes)
{
    int len = str.length();
    if (!len)
        return;

    const QChar *uc = str.unicode();
    const QUnicodeTables::Properties *prop = QUnicodeTables::properties(uc->unicode());
    int cls = prop->line_break_class;
    if (cls >= QUnicodeTables::LineBreak_CM)
        cls = QUnicodeTables::LineBreak_ID;

    charAttributes[0].softBreak = false;
    charAttributes[0].whiteSpace = (cls == QUnicodeTables::LineBreak_SP || cls == QUnicodeTables::LineBreak_BK);
    charAttributes[0].charStop = true;
    charAttributes[0].category = prop->category;

    for (int i = 1; i < len; ++i) {
        prop = QUnicodeTables::properties(uc[i].unicode());
        int ncls = prop->line_break_class;
        int category = prop->category;
        if (category == QChar::Mark_NonSpacing)
            goto nsm;
        
        if (category == QChar::Other_Surrogate) {
            
            if (uc[i].unicode() >= 0xd800 && uc[i].unicode() < 0xdc00 && i < len-1
                && uc[i+1].unicode() >= 0xdc00 && uc[i+1].unicode() < 0xe000)
                goto nsm;
            
        }

        if (ncls == QUnicodeTables::LineBreak_SP || ncls == QUnicodeTables::LineBreak_BK) {
            charAttributes[i].softBreak = false;
            charAttributes[i].whiteSpace = true;
            charAttributes[i].charStop = true;
            charAttributes[i].category = QChar::Separator_Space;
            cls = ncls;
            continue;
        }


	if (cls == QUnicodeTables::LineBreak_SA && ncls == QUnicodeTables::LineBreak_SA) {
            
            
            charAttributes[i].softBreak = true;
            charAttributes[i].whiteSpace = false;
            charAttributes[i].charStop = true;
            charAttributes[i].category = QChar::Separator_Space;
            cls = ncls;
            continue;
        }
        {
	    int tcls = ncls;
	    if (tcls >= QUnicodeTables::LineBreak_SA)
		tcls = QUnicodeTables::LineBreak_ID;
	    if (cls >= QUnicodeTables::LineBreak_SA)
		cls = QUnicodeTables::LineBreak_ID;

	    bool softBreak;
	    int brk = breakTable[cls][tcls];
	    if (brk == Ibk)
		softBreak = (cls == QUnicodeTables::LineBreak_SP);
	    else
		softBreak = (brk == Dbk);

	    charAttributes[i].softBreak = softBreak;
	    charAttributes[i].whiteSpace = false;
	    charAttributes[i].charStop = true;
	    charAttributes[i].category = category;
	    cls = ncls;
	}
        continue;
    nsm:
        charAttributes[i].softBreak = false;
        charAttributes[i].whiteSpace = false;
        charAttributes[i].charStop = false;
        charAttributes[i].category = QChar::Mark_NonSpacing;
    }
}

#line 1 "text/qtextengine_unix.cpp"



















 

#line 1 "../../include/QtCore/qdebug.h"
#line 23 "text/qtextengine_unix.cpp"







void QTextEngine::shapeText(int item) const
{
    do {if(!(item < layoutData->items . size()))qt_assert("item < layoutData->items.size()","text/qtextengine_unix.cpp",32);} while (0);
    QScriptItem &si = layoutData->items[item];

    if (si.num_glyphs)
        return;

    si.glyph_data_offset = layoutData->used;

    QFontEngine *font = fontEngine(si, &si.ascent, &si.descent);

    QShaperItem shaper_item;
    shaper_item.script = si.analysis.script;
    shaper_item.string = &layoutData->string;
    shaper_item.from = si.position;
    shaper_item.length = length(item);
    shaper_item.font = font;
    shaper_item.num_glyphs = qMax(int(layoutData->num_glyphs - layoutData->used), shaper_item.length);
    shaper_item.flags = si.analysis.bidiLevel % 2 ? RightToLeft : 0;
    if (option.useDesignMetrics())
        shaper_item.flags |= DesignMetrics;


    while (1) {

        ensureSpace(shaper_item.num_glyphs);
        shaper_item.num_glyphs = layoutData->num_glyphs - layoutData->used;

        shaper_item.glyphs = glyphs(&si);
        shaper_item.log_clusters = logClusters(&si);
        if (qt_scriptEngines[shaper_item.script].shape(&shaper_item))
            break;
    }


    si.num_glyphs = shaper_item.num_glyphs;

    layoutData->used += si.num_glyphs;

    QGlyphLayout *g = shaper_item.glyphs;



    if (this->font(si).d->kerning)

        font->doKerning(si.num_glyphs, g, option.useDesignMetrics() ? QFlag(QTextEngine::DesignMetrics) : QFlag(0));

    si.width = 0;
    QGlyphLayout *end = g + si.num_glyphs;
    while (g < end)
        si.width += (g++)->advance.x;

    return;
}

#line 832 "text/qtextengine.cpp"






static void init(QTextEngine *e)
{




    e->ignoreBidi = false;
    e->cacheGlyphs = false;

    e->layoutData = 0;

    e->minWidth = 0;
    e->maxWidth = 0;

    e->underlinePositions = 0;
    e->specialData = 0;
    e->stackEngine = false;
}

QTextEngine::QTextEngine()
{
    init(this);
}

QTextEngine::QTextEngine(const QString &str, const QFont &f)
    : fnt(f)
{
    init(this);
    text = str;
}

QTextEngine::~QTextEngine()
{
    if (!stackEngine)
        delete layoutData;
    delete specialData;
}

const QCharAttributes *QTextEngine::attributes() const
{
    if (layoutData && layoutData->haveCharAttributes)
        return (QCharAttributes *) layoutData->memory;

    itemize();
    ensureSpace(layoutData->string.length());
    
    calcLineBreaks(layoutData->string, (QCharAttributes *) layoutData->memory);

    for (int i = 0; i < layoutData->items.size(); i++) {
        const QScriptItem &si = layoutData->items[i];
        int script = si.analysis.script;





        if (script == QUnicodeTables::Inherited)
            script = QUnicodeTables::Common;
        AttributeFunction attributes = qt_scriptEngines[script].charAttributes;
        if (!attributes)
            continue;
        int from = si.position;
        int len = length(i);
        attributes(script, layoutData->string, from, len, (QCharAttributes *) layoutData->memory);
    }
    
    layoutData->haveCharAttributes = true;
    return (QCharAttributes *) layoutData->memory;
}

void QTextEngine::shape(int item) const
{
    if (layoutData->items[item].isObject) {
        ensureSpace(1);
        if (block.docHandle()) {
            QTextFormat format = formats()->format(formatIndex(&layoutData->items[item]));
            docLayout()->resizeInlineObject(QTextInlineObject(item, const_cast<QTextEngine *>(this)),
                                            layoutData->items[item].position + block.position(), format);
        }
    } else {
        shapeText(item);
    }
}

void QTextEngine::invalidate()
{
    freeMemory();
    lines.clear();
    minWidth = 0;
    maxWidth = 0;
    if (specialData)
        specialData->resolvedFormatIndices.clear();
}

void QTextEngine::validate() const
{
    if (layoutData)
        return;
    layoutData = new LayoutData();
    if (block.docHandle())
        layoutData->string = block.text();
    else
        layoutData->string = text;
    if (specialData && specialData->preeditPosition != -1)
        layoutData->string.insert(specialData->preeditPosition, specialData->preeditText);
}


void QTextEngine::itemize() const
{
    validate();
    if (layoutData->items.size())
        return;

    if (layoutData->string.length() == 0)
        return;

    if (!ignoreBidi) {
        layoutData->hasBidi = bidiItemize(const_cast<QTextEngine *>(this), (option.textDirection() == Qt::RightToLeft));
    } else {
        QBidiControl control(false);
        int start = 0;
        int stop = layoutData->string.length() - 1;
        appendItems(const_cast<QTextEngine *>(this), start, stop, control, QChar::DirL);
    }

    addRequiredBoundaries();
    resolveAdditionalFormats();
}

int QTextEngine::findItem(int strPos) const
{
    itemize();

    
    int item;
    for (item = layoutData->items.size()-1; item > 0; --item) {
        if (layoutData->items[item].position <= strPos)
            break;
    }
    return item;
}

QFixed QTextEngine::width(int from, int len) const
{
    itemize();

    QFixed w = 0;


    for (int i = 0; i < layoutData->items.size(); i++) {
        const QScriptItem *si = layoutData->items.constData() + i;
        int pos = si->position;
        int ilen = length(i);

        if (pos >= from + len)
            break;
        if (pos + ilen > from) {
            if (!si->num_glyphs)
                shape(i);
            
            if (si->isObject) {
                w += si->width;
                continue;
            } else if (si->isTab) {
                w = nextTab(si, w);
                continue;
            }

            QGlyphLayout *glyphs = this->glyphs(si);
            unsigned short *logClusters = this->logClusters(si);





            
            int charFrom = from - pos;
            if (charFrom < 0)
                charFrom = 0;
            int glyphStart = logClusters[charFrom];
            if (charFrom > 0 && logClusters[charFrom-1] == glyphStart)
                while (charFrom < ilen && logClusters[charFrom] == glyphStart)
                    charFrom++;
            if (charFrom < ilen) {
                glyphStart = logClusters[charFrom];
                int charEnd = from + len - 1 - pos;
                if (charEnd >= ilen)
                    charEnd = ilen-1;
                int glyphEnd = logClusters[charEnd];
                while (charEnd < ilen && logClusters[charEnd] == glyphEnd)
                    charEnd++;
                glyphEnd = (charEnd == ilen) ? si->num_glyphs : logClusters[charEnd];


                for (int i = glyphStart; i < glyphEnd; i++)
                    w += glyphs[i].advance.x;
            }
        }
    }

    return w;
}

glyph_metrics_t QTextEngine::boundingBox(int from,  int len) const
{
    itemize();

    glyph_metrics_t gm;

    for (int i = 0; i < layoutData->items.size(); i++) {
        const QScriptItem *si = layoutData->items.constData() + i;
        int pos = si->position;
        int ilen = length(i);
        if (pos > from + len)
            break;
        if (pos + len > from) {
            if (!si->num_glyphs)
                shape(i);
            unsigned short *logClusters = this->logClusters(si);
            QGlyphLayout *glyphs = this->glyphs(si);

            
            int charFrom = from - pos;
            if (charFrom < 0)
                charFrom = 0;
            int glyphStart = logClusters[charFrom];
            if (charFrom > 0 && logClusters[charFrom-1] == glyphStart)
                while (charFrom < ilen && logClusters[charFrom] == glyphStart)
                    charFrom++;
            if (charFrom < ilen) {
                glyphStart = logClusters[charFrom];
                int charEnd = from + len - 1 - pos;
                if (charEnd >= ilen)
                    charEnd = ilen-1;
                int glyphEnd = logClusters[charEnd];
                while (charEnd < ilen && logClusters[charEnd] == glyphEnd)
                    charEnd++;
                glyphEnd = (charEnd == ilen) ? si->num_glyphs : logClusters[charEnd];
                if (glyphStart <= glyphEnd ) {
                    QFontEngine *fe = fontEngine(*si);
                    glyph_metrics_t m = fe->boundingBox(glyphs+glyphStart, glyphEnd-glyphStart);
                    gm.x = qMin(gm.x, m.x + gm.xoff);
                    gm.y = qMin(gm.y, m.y + gm.yoff);
                    gm.width = qMax(gm.width, m.width+gm.xoff);
                    gm.height = qMax(gm.height, m.height+gm.yoff);
                    gm.xoff += m.xoff;
                    gm.yoff += m.yoff;
                }
            }
        }
    }
    return gm;
}

QFont QTextEngine::font(const QScriptItem &si) const
{
    if (!hasFormats())
        return fnt;
    QTextCharFormat f = format(&si);
    QFont font = f.font();

    if (block.docHandle()) {
        
        QPaintDevice *pdev = block.docHandle()->layout()->paintDevice();
        if (pdev)
            font = QFont(font, pdev);
    } else {
        font = font.resolve(fnt);
    }

    if (f.verticalAlignment() != QTextCharFormat::AlignNormal)
        font.setPointSize((font.pointSize() * 2) / 3);

    return font;
}

QFontEngine *QTextEngine::fontEngine(const QScriptItem &si, QFixed *ascent, QFixed *descent) const
{
    QFontEngine *engine;
    QFontEngine *scaledEngine = 0;
    int script = si.analysis.script;
#line 1126 "text/qtextengine.cpp"
    
    if (!hasFormats()) {
        engine = fnt.d->engineForScript(script);




    } else {
        QTextCharFormat f = format(&si);
        QFont font = f.font();

        if (block.docHandle()) {
            
            QPaintDevice *pdev = block.docHandle()->layout()->paintDevice();
            if (pdev)
                font = QFont(font, pdev);
        } else {
            font = font.resolve(fnt);
        }
        engine = font.d->engineForScript(script);




        if (f.verticalAlignment() != QTextCharFormat::AlignNormal) {
            font.setPointSize((font.pointSize() * 2) / 3);
            scaledEngine = font.d->engineForScript(script);




        }
    }

    if (ascent) {
        *ascent = engine->ascent();
        *descent = engine->descent();
    }
    
    if (scaledEngine)
        return scaledEngine;
    return engine;
}

struct QJustificationPoint {
    int type;
    QFixed kashidaWidth;
    QGlyphLayout *glyph;
    QFontEngine *fontEngine;
};

template <> class QTypeInfo<QJustificationPoint> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QJustificationPoint)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QJustificationPoint"; } };

static void set(QJustificationPoint *point, int type, QGlyphLayout *glyph, QFontEngine *fe)
{
    point->type = type;
    point->glyph = glyph;
    point->fontEngine = fe;

    if (type >= QGlyphLayout::Arabic_Normal) {
        QChar ch(0x640); 
        QGlyphLayout glyphs[8];
        int nglyphs = 7;
        fe->stringToCMap(&ch, 1, glyphs, &nglyphs, 0);
        if (glyphs[0].glyph && glyphs[0].advance.x != 0) {
            point->kashidaWidth = glyphs[0].advance.x;
        } else {
            point->type = QGlyphLayout::NoJustification;
            point->kashidaWidth = 0;
        }
    }
}


void QTextEngine::justify(const QScriptLine &line)
{

    if (line.gridfitted && line.justified)
        return;

    if (!line.gridfitted) {
        
        const_cast<QScriptLine &>(line).gridfitted = true;
    }

    if ((option.alignment() & Qt::AlignHorizontal_Mask) != Qt::AlignJustify)
        return;

    itemize();

    if (line.from + (int)line.length == layoutData->string.length()
        || layoutData->string.at(line.from + line.length - 1) == QChar::LineSeparator)
        return;

    
    int maxJustify = 0;

    
    int line_length = line.length;
    const QCharAttributes *a = attributes()+line.from;
    while (line_length && a[line_length-1].whiteSpace)
        --line_length;
    
    --line_length;

    if (!line_length)
        return;

    int firstItem = findItem(line.from);
    int nItems = findItem(line.from + line_length - 1) - firstItem + 1;

    QVarLengthArray<QJustificationPoint> justificationPoints;
    int nPoints = 0;

    QFixed minKashida = 0x100000;

    
    
    
    for (int i = 0; i < nItems; ++i) {
        QScriptItem &si = layoutData->items[firstItem + i];
        if (!si.num_glyphs)
            shape(firstItem + i);
    }

    for (int i = 0; i < nItems; ++i) {
        QScriptItem &si = layoutData->items[firstItem + i];

        int kashida_type = QGlyphLayout::Arabic_Normal;
        int kashida_pos = -1;

        int start = qMax(line.from - si.position, 0);
        int end = qMin(line.from + line_length - (int)si.position, length(firstItem+i));

        unsigned short *log_clusters = logClusters(&si);

        int gs = log_clusters[start];
        int ge = (end == length(firstItem+i) ? si.num_glyphs : log_clusters[end]);

        QGlyphLayout *g = glyphs(&si);

        for (int i = gs; i < ge; ++i) {
            g[i].justificationType = QGlyphLayout::JustifyNone;
            g[i].nKashidas = 0;
            g[i].space_18d6 = 0;

            justificationPoints.resize(nPoints+3);
            int justification = g[i].attributes.justification;

            switch(justification) {
            case QGlyphLayout::NoJustification:
                break;
            case QGlyphLayout::Space          :
                
            case QGlyphLayout::Arabic_Space   :
                if (kashida_pos >= 0) {

                    set(&justificationPoints[nPoints], kashida_type, g+kashida_pos, fontEngine(si));
                    minKashida = qMin(minKashida, justificationPoints[nPoints].kashidaWidth);
                    maxJustify = qMax(maxJustify, justificationPoints[nPoints].type);
                    ++nPoints;
                }
                kashida_pos = -1;
                kashida_type = QGlyphLayout::Arabic_Normal;
                
            case QGlyphLayout::Character      :
                set(&justificationPoints[nPoints++], justification, g+i, fontEngine(si));
                maxJustify = qMax(maxJustify, justification);
                break;
            case QGlyphLayout::Arabic_Normal  :
            case QGlyphLayout::Arabic_Waw     :
            case QGlyphLayout::Arabic_BaRa    :
            case QGlyphLayout::Arabic_Alef    :
            case QGlyphLayout::Arabic_HaaDal  :
            case QGlyphLayout::Arabic_Seen    :
            case QGlyphLayout::Arabic_Kashida :
                if (justification >= kashida_type) {
                    kashida_pos = i;
                    kashida_type = justification;
                }
            }
        }
        if (kashida_pos >= 0) {
            set(&justificationPoints[nPoints], kashida_type, g+kashida_pos, fontEngine(si));
            minKashida = qMin(minKashida, justificationPoints[nPoints].kashidaWidth);
            maxJustify = qMax(maxJustify, justificationPoints[nPoints].type);
            ++nPoints;
        }
    }

    QFixed need = line.width - line.textWidth;
    if (need < 0) {
        
        const_cast<QScriptLine &>(line).justified = true;
        return;
    }




    
    if (maxJustify >= QGlyphLayout::Arabic_Normal) {
        while (need >= minKashida) {
            for (int type = maxJustify; need >= minKashida && type >= QGlyphLayout::Arabic_Normal; --type) {
                for (int i = 0; need >= minKashida && i < nPoints; ++i) {
                    if (justificationPoints[i].type == type && justificationPoints[i].kashidaWidth <= need) {
                        justificationPoints[i].glyph->nKashidas++;
                        
                        justificationPoints[i].glyph->space_18d6 += justificationPoints[i].kashidaWidth.value();
                        need -= justificationPoints[i].kashidaWidth;

                    }
                }
            }
        }
    }
    do {if(!(need >= 0))qt_assert("need >= 0","text/qtextengine.cpp",1342);} while (0);
    if (!need)
        goto end;

    maxJustify = qMin(maxJustify, (int)QGlyphLayout::Space);
    for (int type = maxJustify; need != 0 && type > 0; --type) {
        int n = 0;
        for (int i = 0; i < nPoints; ++i) {
            if (justificationPoints[i].type == type)
                ++n;
        }


        if (!n)
            continue;

        for (int i = 0; i < nPoints; ++i) {
            if (justificationPoints[i].type == type) {
                QFixed add = need/n;

                justificationPoints[i].glyph->space_18d6 = add.value();
                need -= add;
                --n;
            }
        }

        do {if(!(!need))qt_assert("!need","text/qtextengine.cpp",1368);} while (0);
    }
 end:
    const_cast<QScriptLine &>(line).justified = true;
}

void QScriptLine::setDefaultHeight(QTextEngine *eng)
{
    QFont f;
    QFontEngine *e;

    if (eng->block.docHandle()) {
        f = eng->block.charFormat().font();
        
        QPaintDevice *pdev = eng->block.docHandle()->layout()->paintDevice();
        if (pdev)
            f = QFont(f, pdev);
        e = f.d->engineForScript(QUnicodeTables::Common);
    } else {
        e = eng->fnt.d->engineForScript(QUnicodeTables::Common);
    }

    ascent = qMax(ascent, e->ascent());
    descent = qMax(descent, e->descent());
}

QTextEngine::LayoutData::LayoutData()
{
    memory = 0;
    allocated = 0;
    num_glyphs = 0;
    memory_on_stack = false;
    used = 0;
    hasBidi = false;
    inLayout = false;
    haveCharAttributes = false;
    logClustersPtr = 0;
    glyphPtr = 0;
}

QTextEngine::LayoutData::LayoutData(const QString &str, void **stack_memory, int _allocated)
    : string(str)
{
    allocated = _allocated;
    
    int space_charAttributes = sizeof(QCharAttributes)*string.length()/sizeof(void*) + 1;
    int space_logClusters = sizeof(unsigned short)*string.length()/sizeof(void*) + 1;
    available_glyphs = ((int)allocated - space_charAttributes - space_logClusters)*(int)sizeof(void*)/(int)sizeof(QGlyphLayout) - 2;

    if (available_glyphs < str.length()) {
        
        num_glyphs = 0;
        allocated = 0;

        memory_on_stack = false;
        memory = 0;
        logClustersPtr = 0;
        glyphPtr = 0;
    } else {
        num_glyphs = str.length();
        allocated = str.length();
        
        memory_on_stack = true;
        memory = stack_memory;
        logClustersPtr = (unsigned short *)(memory + space_charAttributes);
        glyphPtr = (QGlyphLayout *)(memory + space_charAttributes + space_logClusters);
        memset(memory, 0, space_charAttributes*sizeof(void *));
        memset(glyphPtr, 0, num_glyphs*sizeof(QGlyphLayout));
    }
    used = 0;
    hasBidi = false;
    inLayout = false;
    haveCharAttributes = false;
}

QTextEngine::LayoutData::~LayoutData()
{
    if (!memory_on_stack)
        free(memory);
    memory = 0;
}

void QTextEngine::LayoutData::reallocate(int totalGlyphs)
{
    do {if(!(totalGlyphs >= num_glyphs))qt_assert("totalGlyphs >= num_glyphs","text/qtextengine.cpp",1452);} while (0);
    if (memory_on_stack && available_glyphs >= totalGlyphs) {
        memset(glyphPtr + num_glyphs, 0, (totalGlyphs - num_glyphs)*sizeof(QGlyphLayout));
        num_glyphs = totalGlyphs;
        return;
    }
    
    int space_charAttributes = sizeof(QCharAttributes)*string.length()/sizeof(void*) + 1;
    int space_logClusters = sizeof(unsigned short)*string.length()/sizeof(void*) + 1;
    int space_glyphs = sizeof(QGlyphLayout)*totalGlyphs/sizeof(void*) + 2;

    int newAllocated = space_charAttributes + space_glyphs + space_logClusters;
    void **old_mem = memory;
    memory = (void **)::realloc(memory_on_stack ? 0 : old_mem, newAllocated*sizeof(void *));
    if (memory_on_stack && memory)
        memcpy(memory, old_mem, allocated*sizeof(void *));
    memory_on_stack = false;

    void **m = memory;
    m += space_charAttributes;
    logClustersPtr = (unsigned short *) m;
    m += space_logClusters;

    glyphPtr = (QGlyphLayout *) m;

    memset(((char *)memory) + allocated*sizeof(void *), 0,
           (newAllocated - allocated)*sizeof(void *));

    allocated = newAllocated;
    num_glyphs = totalGlyphs;
}

void QTextEngine::freeMemory()
{
    if (!stackEngine) {
        delete layoutData;
        layoutData = 0;
    } else {
        layoutData->used = 0;
        layoutData->hasBidi = false;
        layoutData->inLayout = false;
        layoutData->haveCharAttributes = false;
    }
    for (int i = 0; i < lines.size(); ++i) {
        lines[i].justified = 0;
        lines[i].gridfitted = 0;
    }
}

int QTextEngine::formatIndex(const QScriptItem *si) const
{
    if (specialData && !specialData->resolvedFormatIndices.isEmpty())
        return specialData->resolvedFormatIndices.at(si - &layoutData->items[0]);
    QTextDocumentPrivate *p = block.docHandle();
    if (!p)
        return -1;
    int pos = si->position;
    if (specialData && si->position >= specialData->preeditPosition) {
        if (si->position < specialData->preeditPosition + specialData->preeditText.length())
            pos = qMax(specialData->preeditPosition - 1, 0);
        else
            pos -= specialData->preeditText.length();
    }
    QTextDocumentPrivate::FragmentIterator it = p->find(block.position() + pos);
    return it.value()->format;
}


QTextCharFormat QTextEngine::format(const QScriptItem *si) const
{
    QTextCharFormat format;
    const QTextFormatCollection *formats = 0;
    if (block.docHandle()) {
        formats = this->formats();
        format = formats->charFormat(formatIndex(si));
    }
    if (specialData && specialData->resolvedFormatIndices.isEmpty()) {
        int end = si->position + length(si);
        for (int i = 0; i < specialData->addFormats.size(); ++i) {
            const QTextLayout::FormatRange &r = specialData->addFormats.at(i);
            if (r.start <= si->position && r.start + r.length >= end) {
                if (!specialData->addFormatIndices.isEmpty())
                    format.merge(formats->format(specialData->addFormatIndices.at(i)));
                else
                    format.merge(r.format);
            }
        }
    }
    return format;
}

void QTextEngine::addRequiredBoundaries() const
{
    int position = 0;
    SpecialData *s = specialData;

    const QTextDocumentPrivate *p = block.docHandle();
    if (p) {
        QTextDocumentPrivate::FragmentIterator it = p->find(block.position());
        QTextDocumentPrivate::FragmentIterator end = p->find(block.position() + block.length() - 1); 
        int format = it.value()->format;

        for (; it != end; ++it) {
            if (s && position >= s->preeditPosition) {
                position += s->preeditText.length();
                s = 0;
            }
            const QTextFragmentData * const frag = it.value();
            if (format != frag->format)
                setBoundary(position);
            format = frag->format;
            position += frag->size;
        }
    }
    if (specialData) {
        for (int i = 0; i < specialData->addFormats.size(); ++i) {
            const QTextLayout::FormatRange &r = specialData->addFormats.at(i);
            setBoundary(r.start);
            setBoundary(r.start + r.length);
            
        }
    }
}

bool QTextEngine::atWordSeparator(int position) const
{
    const QChar c = layoutData->string.at(position);
    return c == '.'
        || c == ','
        || c == ':'
        || c == ';'
        || c == '-'
        || c == '<'
        || c == '>'
        || c == '['
        || c == ']'
        || c == '('
        || c == ')'
        || c == '{'
        || c == '}'
        || c == QChar::Nbsp
        ;
}

void QTextEngine::indexAdditionalFormats()
{
    if (!block.docHandle())
        return;

    specialData->addFormatIndices.resize(specialData->addFormats.count());
    QTextFormatCollection * const formats = this->formats();

    for (int i = 0; i < specialData->addFormats.count(); ++i) {
        specialData->addFormatIndices[i] = formats->indexForFormat(specialData->addFormats.at(i).format);
        specialData->addFormats[i].format = QTextCharFormat();
    }
}

void QTextEngine::setBoundary(int strPos) const
{
    if (strPos <= 0 || strPos >= layoutData->string.length())
        return;

    int itemToSplit = 0;
    while (itemToSplit < layoutData->items.size() && layoutData->items[itemToSplit].position <= strPos)
        itemToSplit++;
    itemToSplit--;
    if (layoutData->items[itemToSplit].position == strPos) {
        
        return;
    }
    splitItem(itemToSplit, strPos - layoutData->items[itemToSplit].position);
}

void QTextEngine::splitItem(int item, int pos) const
{
    if (pos <= 0)
        return;

    layoutData->items.insert(item + 1, QScriptItem(layoutData->items[item]));
    QScriptItem &oldItem = layoutData->items[item];
    QScriptItem &newItem = layoutData->items[item+1];
    newItem.position += pos;

    if (oldItem.num_glyphs) {
        
        int breakGlyph = logClusters(&oldItem)[pos];

        newItem.num_glyphs = oldItem.num_glyphs - breakGlyph;
        oldItem.num_glyphs = breakGlyph;
        newItem.glyph_data_offset = oldItem.glyph_data_offset + breakGlyph;

        for (int i = 0; i < newItem.num_glyphs; i++)
            logClusters(&newItem)[i] -= breakGlyph;

        QFixed w = 0;
        const QGlyphLayout *g = glyphs(&oldItem);
        for(int j = 0; j < breakGlyph; ++j)
            w += (g++)->advance.x;

        newItem.width = oldItem.width - w;
        oldItem.width = w;
    }


}

QFixed QTextEngine::nextTab(const QScriptItem *si, QFixed x) const
{
    
    if (!(option.alignment() & Qt::AlignLeft) ||
        option.textDirection() != Qt::LeftToRight)
        return x + si->width;

    QList<qreal> tabArray = option.tabArray();
    if (!tabArray.isEmpty()) {
        for (int i = 0; i < tabArray.size(); ++i) {
            if (tabArray.at(i) > x.toReal())
                return QFixed::fromReal(tabArray.at(i));
        }
    }
    QFixed tab = QFixed::fromReal(option.tabStop());
    if (tab <= 0)
        tab = 80; 
    return ((x / tab).truncate() + 1) * tab;
}

void QTextEngine::resolveAdditionalFormats() const
{
    if (!specialData || specialData->addFormats.isEmpty()
        || !block.docHandle())
        return;

    QTextFormatCollection *collection = this->formats();

    specialData->resolvedFormatIndices.clear();
    QVector<int> indices(layoutData->items.count());
    for (int i = 0; i < layoutData->items.count(); ++i) {
        QTextCharFormat f = format(&layoutData->items.at(i));
        indices[i] = collection->indexForFormat(f);
    }
    specialData->resolvedFormatIndices = indices;
}

QStackTextEngine::QStackTextEngine(const QString &string, const QFont &f)
    : _layoutData(string, _memory, MemSize)
{
    fnt = f;
    text = string;
    stackEngine = true;
    layoutData = &_layoutData;
}