# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp"
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit//"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp"
# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp"
# 1 "/usr/include/qt4/QtWebKit/qwebpage.h" 1
# 24 "/usr/include/qt4/QtWebKit/qwebpage.h"
# 1 "/usr/include/qt4/QtWebKit/qwebsettings.h" 1
# 23 "/usr/include/qt4/QtWebKit/qwebsettings.h"
# 1 "/usr/include/qt4/QtWebKit/qwebkitglobal.h" 1
# 23 "/usr/include/qt4/QtWebKit/qwebkitglobal.h"
# 1 "/usr/include/qt4/QtCore/qglobal.h" 1
# 45 "/usr/include/qt4/QtCore/qglobal.h"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 46 "/usr/include/qt4/QtCore/qglobal.h" 2
# 62 "/usr/include/qt4/QtCore/qglobal.h"
# 1 "/usr/include/qt4/QtCore/qconfig.h" 1


# 1 "/usr/include/qt4/Gentoo/gentoo-qconfig.h" 1
# 4 "/usr/include/qt4/QtCore/qconfig.h" 2
# 63 "/usr/include/qt4/QtCore/qglobal.h" 2
# 828 "/usr/include/qt4/QtCore/qglobal.h"









typedef signed char qint8;
typedef unsigned char quint8;
typedef short qint16;
typedef unsigned short quint16;
typedef int qint32;
typedef unsigned int quint32;
# 851 "/usr/include/qt4/QtCore/qglobal.h"
typedef long long qint64;
typedef unsigned long long quint64;


typedef qint64 qlonglong;
typedef quint64 qulonglong;
# 881 "/usr/include/qt4/QtCore/qglobal.h"
template <int> struct QIntegerForSize;
template <> struct QIntegerForSize<1> { typedef quint8 Unsigned; typedef qint8 Signed; };
template <> struct QIntegerForSize<2> { typedef quint16 Unsigned; typedef qint16 Signed; };
template <> struct QIntegerForSize<4> { typedef quint32 Unsigned; typedef qint32 Signed; };
template <> struct QIntegerForSize<8> { typedef quint64 Unsigned; typedef qint64 Signed; };
template <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> { };
typedef QIntegerForSizeof<void*>::Unsigned quintptr;
typedef QIntegerForSizeof<void*>::Signed qptrdiff;






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

# 1063 "/usr/include/qt4/QtCore/qglobal.h"
typedef int QNoImplicitBoolCast;
# 1075 "/usr/include/qt4/QtCore/qglobal.h"
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 - qreal(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)); }
# 1133 "/usr/include/qt4/QtCore/qglobal.h"
class QDataStream;
# 1158 "/usr/include/qt4/QtCore/qglobal.h"
# 1 "/usr/include/qt4/QtCore/qfeatures.h" 1
# 1159 "/usr/include/qt4/QtCore/qglobal.h" 2
# 1368 "/usr/include/qt4/QtCore/qglobal.h"
inline void qt_noop() {}
# 1401 "/usr/include/qt4/QtCore/qglobal.h"
class QString;
class QSysInfo {
public:
    enum Sizes {
        WordSize = (sizeof(void *)<<3)
    };
# 1416 "/usr/include/qt4/QtCore/qglobal.h"
    enum Endian {
        BigEndian,
        LittleEndian






        , ByteOrder = LittleEndian



    };
# 1519 "/usr/include/qt4/QtCore/qglobal.h"
};

 const char *qVersion();
 bool qSharedBuild();
# 1592 "/usr/include/qt4/QtCore/qglobal.h"
 void qDebug(const char *, ...)

    __attribute__ ((format (printf, 1, 2)))

;

 void qWarning(const char *, ...)

    __attribute__ ((format (printf, 1, 2)))

;

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

    __attribute__ ((format (printf, 1, 2)))

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

    __attribute__ ((format (printf, 1, 2)))

;




 void qErrnoWarning(int code, const char *msg, ...);
 void qErrnoWarning(const char *msg, ...);
# 1632 "/usr/include/qt4/QtCore/qglobal.h"
class QDebug;
class QNoDebug;

 inline QDebug qDebug();
 inline QDebug qWarning();
 inline QDebug qCritical();
# 1652 "/usr/include/qt4/QtCore/qglobal.h"
 void qt_assert(const char *assertion, const char *file, int line);
# 1666 "/usr/include/qt4/QtCore/qglobal.h"
 void qt_assert_x(const char *where, const char *what, const char *file, int line);
# 1676 "/usr/include/qt4/QtCore/qglobal.h"
 void qt_check_pointer(const char *, int);


 void qBadAlloc();
# 1692 "/usr/include/qt4/QtCore/qglobal.h"
template <typename T>
inline T *q_check_ptr(T *p) { do { if (!(p)) qBadAlloc(); } while (0); return p; }
# 1722 "/usr/include/qt4/QtCore/qglobal.h"
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);
# 1776 "/usr/include/qt4/QtCore/qglobal.h"
template <typename T> class QBasicAtomicPointer;


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


template <typename T>
class QGlobalStaticDeleter
{
public:
    QGlobalStatic<T> &globalStatic;
    QGlobalStaticDeleter(QGlobalStatic<T> &_globalStatic)
        : globalStatic(_globalStatic)
    { }

    inline ~QGlobalStaticDeleter()
    {
        delete globalStatic.pointer;
        globalStatic.pointer = 0;
        globalStatic.destroyed = true;
    }
};
# 1853 "/usr/include/qt4/QtCore/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.000000000001 * qMin(qAbs(p1), qAbs(p2)));
}

static inline bool qFuzzyCompare(float p1, float p2)
{
    return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
}




static inline bool qFuzzyIsNull(double d)
{
    return qAbs(d) <= 0.000000000001;
}




static inline bool qFuzzyIsNull(float f)
{
    return qAbs(f) <= 0.00001f;
}






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;
}
# 1959 "/usr/include/qt4/QtCore/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
    };
};
# 2017 "/usr/include/qt4/QtCore/qglobal.h"
enum {
    Q_COMPLEX_TYPE = 0,
    Q_PRIMITIVE_TYPE = 0x1,
    Q_STATIC_TYPE = 0,
    Q_MOVABLE_TYPE = 0x2,
    Q_DUMMY_TYPE = 0x4
};
# 2040 "/usr/include/qt4/QtCore/qglobal.h"
template <typename T>
inline void qSwap(T &value1, T &value2)
{
    const T t = value1;
    value1 = value2;
    value2 = t;
}
# 2067 "/usr/include/qt4/QtCore/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 *qMallocAligned(size_t size, size_t alignment);
 void *qReallocAligned(void *ptr, size_t size, size_t oldsize, size_t alignment);
 void qFreeAligned(void *ptr);
 void *qMemCopy(void *dest, const void *src, size_t n);
 void *qMemSet(void *dest, int c, size_t n);
# 2137 "/usr/include/qt4/QtCore/qglobal.h"
class QFlag
{
    int i;
public:
    inline QFlag(int i);
    inline operator int() const { return i; }
};

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

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

inline QIncompatibleFlag::QIncompatibleFlag(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; }

    inline bool testFlag(Enum f) const { return (i & f) == f && (f != 0 || i == int(f) ); }
};
# 2224 "/usr/include/qt4/QtCore/qglobal.h"
template <typename T>
class QForeachContainer {
public:
    inline QForeachContainer(const T& t) : c(t), brk(0), i(c.begin()), e(c.end()) { }
    const T c;
    int brk;
    typename T::const_iterator i, e;
};
# 2316 "/usr/include/qt4/QtCore/qglobal.h"
template <typename T> static inline T *qGetPtrHelper(T *ptr) { return ptr; }
template <typename Wrapper> static inline typename Wrapper::pointer qGetPtrHelper(const Wrapper &p) { return p.data(); }
# 2349 "/usr/include/qt4/QtCore/qglobal.h"
 QString qtTrId(const char *id, int n = -1);
# 2379 "/usr/include/qt4/QtCore/qglobal.h"
class QByteArray;
 QByteArray qgetenv(const char *varName);
 bool qputenv(const char *varName, const QByteArray& value);

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




 void qsrand(uint seed);
 int qrand();
# 2552 "/usr/include/qt4/QtCore/qglobal.h"
enum QtValidLicenseForCoreModule { LicensedCore = true };


enum QtValidLicenseForGuiModule { LicensedGui = true };


enum QtValidLicenseForNetworkModule { LicensedNetwork = true };


enum QtValidLicenseForOpenGLModule { LicensedOpenGL = true };


enum QtValidLicenseForOpenVGModule { LicensedOpenVG = true };


enum QtValidLicenseForSqlModule { LicensedSql = true };


enum QtValidLicenseForMultimediaModule { LicensedMultimedia = true };


enum QtValidLicenseForXmlModule { LicensedXml = true };


enum QtValidLicenseForXmlPatternsModule { LicensedXmlPatterns = true };


enum QtValidLicenseForHelpModule { LicensedHelp = true };


enum QtValidLicenseForScriptModule { LicensedScript = true };


enum QtValidLicenseForScriptToolsModule { LicensedScriptTools = true };


enum QtValidLicenseForQt3SupportLightModule { LicensedQt3SupportLight = true };


enum QtValidLicenseForQt3SupportModule { LicensedQt3Support = true };


enum QtValidLicenseForSvgModule { LicensedSvg = true };


enum QtValidLicenseForDeclarativeModule { LicensedDeclarative = true };


enum QtValidLicenseForActiveQtModule { LicensedActiveQt = true };


enum QtValidLicenseForTestModule { LicensedTest = true };


enum QtValidLicenseForDBusModule { LicensedDBus = true };
# 2640 "/usr/include/qt4/QtCore/qglobal.h"


# 24 "/usr/include/qt4/QtWebKit/qwebkitglobal.h" 2
# 24 "/usr/include/qt4/QtWebKit/qwebsettings.h" 2

# 1 "/usr/include/qt4/QtCore/qstring.h" 1
# 45 "/usr/include/qt4/QtCore/qstring.h"
# 1 "/usr/include/qt4/QtCore/qchar.h" 1
# 47 "/usr/include/qt4/QtCore/qchar.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

class QString;

struct QLatin1Char
{
public:
    inline explicit QLatin1Char(char c) : ch(c) {}




    inline char toLatin1() const { return ch; }
    inline 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,







        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




    };

    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,
        Unicode_4_1,
        Unicode_5_0
    };


    Category category() const;
    Direction direction() const;
    Joining joining() const;
    bool hasMirrored() const;
    unsigned char combiningClass() const;

    QChar mirroredChar() const;
    QString decomposition() const;
    Decomposition decompositionTag() const;

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

    UnicodeVersion unicodeVersion() const;






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


    inline ushort &unicode() { return const_cast<ushort&>(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 bool isLower() const { return category() == Letter_Lowercase; }
    inline bool isUpper() const { return category() == Letter_Uppercase; }
    inline bool isTitleCase() const { return category() == Letter_Titlecase; }

    inline bool isHighSurrogate() const {
        return ((ucs & 0xfc00) == 0xd800);
    }
    inline bool isLowSurrogate() const {
        return ((ucs & 0xfc00) == 0xdc00);
    }

    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);

    static inline uint surrogateToUcs4(ushort high, ushort low) {
        return (uint(high)<<10) + low - 0x35fdc00;
    }
    static inline uint surrogateToUcs4(QChar high, QChar low) {
        return (uint(high.ucs)<<10) + low.ucs - 0x35fdc00;
    }
    static inline ushort highSurrogate(uint ucs4) {
        return ushort((ucs4>>10) + 0xd7c0);
    }
    static inline ushort lowSurrogate(uint ucs4) {
        return ushort(ucs4%0x400 + 0xdc00);
    }

    static Category category(uint ucs4);
    static Category category(ushort ucs2);
    static Direction direction(uint ucs4);
    static Direction direction(ushort ucs2);
    static Joining joining(uint ucs4);
    static Joining joining(ushort ucs2);
    static unsigned char combiningClass(uint ucs4);
    static unsigned char combiningClass(ushort ucs2);

    static uint mirroredChar(uint ucs4);
    static ushort mirroredChar(ushort ucs2);
    static Decomposition decompositionTag(uint ucs4);

    static int digitValue(uint ucs4);
    static int digitValue(ushort ucs2);
    static uint toLower(uint ucs4);
    static ushort toLower(ushort ucs2);
    static uint toUpper(uint ucs4);
    static ushort toUpper(ushort ucs2);
    static uint toTitleCase(uint ucs4);
    static ushort toTitleCase(ushort ucs2);
    static uint toCaseFolded(uint ucs4);
    static ushort toCaseFolded(ushort ucs2);

    static UnicodeVersion unicodeVersion(uint ucs4);
    static UnicodeVersion unicodeVersion(ushort ucs2);

    static QString decomposition(uint ucs4);
# 346 "/usr/include/qt4/QtCore/qchar.h"
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 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 = ushort((ucs & 0xff00) + acell); }
inline void QChar::setRow(uchar arow)
{ ucs = ushort((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 &);





# 46 "/usr/include/qt4/QtCore/qstring.h" 2
# 1 "/usr/include/qt4/QtCore/qbytearray.h" 1
# 45 "/usr/include/qt4/QtCore/qbytearray.h"
# 1 "/usr/include/qt4/QtCore/qatomic.h" 1
# 46 "/usr/include/qt4/QtCore/qatomic.h"
# 1 "/usr/include/qt4/QtCore/qbasicatomic.h" 1
# 47 "/usr/include/qt4/QtCore/qbasicatomic.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

class QBasicAtomicInt
{
public:
# 64 "/usr/include/qt4/QtCore/qbasicatomic.h"
    volatile int _q_value;



    inline bool operator==(int value) const
    {
        return _q_value == value;
    }

    inline bool operator!=(int value) const
    {
        return _q_value != value;
    }

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

    inline operator int() const
    {
        return _q_value;
    }

    inline QBasicAtomicInt &operator=(int value)
    {



        _q_value = value;
        return *this;
    }



    static bool isReferenceCountingNative();
    static bool isReferenceCountingWaitFree();

    bool ref();
    bool deref();

    static bool isTestAndSetNative();
    static bool isTestAndSetWaitFree();

    bool testAndSetRelaxed(int expectedValue, int newValue);
    bool testAndSetAcquire(int expectedValue, int newValue);
    bool testAndSetRelease(int expectedValue, int newValue);
    bool testAndSetOrdered(int expectedValue, int newValue);

    static bool isFetchAndStoreNative();
    static bool isFetchAndStoreWaitFree();

    int fetchAndStoreRelaxed(int newValue);
    int fetchAndStoreAcquire(int newValue);
    int fetchAndStoreRelease(int newValue);
    int fetchAndStoreOrdered(int newValue);

    static bool isFetchAndAddNative();
    static bool isFetchAndAddWaitFree();

    int fetchAndAddRelaxed(int valueToAdd);
    int fetchAndAddAcquire(int valueToAdd);
    int fetchAndAddRelease(int valueToAdd);
    int fetchAndAddOrdered(int valueToAdd);
};

template <typename T>
class QBasicAtomicPointer
{
public:
# 148 "/usr/include/qt4/QtCore/qbasicatomic.h"
    T * volatile _q_value;



    inline bool operator==(T *value) const
    {
        return _q_value == value;
    }

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

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

    inline operator T *() const
    {
        return _q_value;
    }

    inline T *operator->() const
    {
        return _q_value;
    }

    inline QBasicAtomicPointer<T> &operator=(T *value)
    {



        _q_value = value;
        return *this;
    }



    static bool isTestAndSetNative();
    static bool isTestAndSetWaitFree();

    bool testAndSetRelaxed(T *expectedValue, T *newValue);
    bool testAndSetAcquire(T *expectedValue, T *newValue);
    bool testAndSetRelease(T *expectedValue, T *newValue);
    bool testAndSetOrdered(T *expectedValue, T *newValue);

    static bool isFetchAndStoreNative();
    static bool isFetchAndStoreWaitFree();

    T *fetchAndStoreRelaxed(T *newValue);
    T *fetchAndStoreAcquire(T *newValue);
    T *fetchAndStoreRelease(T *newValue);
    T *fetchAndStoreOrdered(T *newValue);

    static bool isFetchAndAddNative();
    static bool isFetchAndAddWaitFree();

    T *fetchAndAddRelaxed(qptrdiff valueToAdd);
    T *fetchAndAddAcquire(qptrdiff valueToAdd);
    T *fetchAndAddRelease(qptrdiff valueToAdd);
    T *fetchAndAddOrdered(qptrdiff valueToAdd);
};
# 221 "/usr/include/qt4/QtCore/qbasicatomic.h"






# 1 "/usr/include/qt4/QtCore/qatomic_arch.h" 1
# 45 "/usr/include/qt4/QtCore/qatomic_arch.h"

# 84 "/usr/include/qt4/QtCore/qatomic_arch.h"
# 1 "/usr/include/qt4/QtCore/qatomic_x86_64.h" 1
# 45 "/usr/include/qt4/QtCore/qatomic_x86_64.h"







inline bool QBasicAtomicInt::isReferenceCountingNative()
{ return true; }
inline bool QBasicAtomicInt::isReferenceCountingWaitFree()
{ return true; }




inline bool QBasicAtomicInt::isTestAndSetNative()
{ return true; }
inline bool QBasicAtomicInt::isTestAndSetWaitFree()
{ return true; }




inline bool QBasicAtomicInt::isFetchAndStoreNative()
{ return true; }
inline bool QBasicAtomicInt::isFetchAndStoreWaitFree()
{ return true; }




inline bool QBasicAtomicInt::isFetchAndAddNative()
{ return true; }
inline bool QBasicAtomicInt::isFetchAndAddWaitFree()
{ return true; }




template <typename T>
inline bool QBasicAtomicPointer<T>::isTestAndSetNative()
{ return true; }
template <typename T>
inline bool QBasicAtomicPointer<T>::isTestAndSetWaitFree()
{ return true; }




template <typename T>
inline bool QBasicAtomicPointer<T>::isFetchAndStoreNative()
{ return true; }
template <typename T>
inline bool QBasicAtomicPointer<T>::isFetchAndStoreWaitFree()
{ return true; }




template <typename T>
inline bool QBasicAtomicPointer<T>::isFetchAndAddNative()
{ return true; }
template <typename T>
inline bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
{ return true; }



inline bool QBasicAtomicInt::ref()
{
    unsigned char ret;
    asm volatile("lock\n"
                 "incl %0\n"
                 "setne %1"
                 : "=m" (_q_value), "=qm" (ret)
                 : "m" (_q_value)
                 : "memory");
    return ret != 0;
}

inline bool QBasicAtomicInt::deref()
{
    unsigned char ret;
    asm volatile("lock\n"
                 "decl %0\n"
                 "setne %1"
                 : "=m" (_q_value), "=qm" (ret)
                 : "m" (_q_value)
                 : "memory");
    return ret != 0;
}

inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
{
    unsigned char ret;
    asm volatile("lock\n"
                 "cmpxchgl %3,%2\n"
                 "sete %1\n"
                 : "=a" (newValue), "=qm" (ret), "+m" (_q_value)
                 : "r" (newValue), "0" (expectedValue)
                 : "memory");
    return ret != 0;
}

inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
{
    asm volatile("xchgl %0,%1"
                 : "=r" (newValue), "+m" (_q_value)
                 : "0" (newValue)
                 : "memory");
    return newValue;
}

inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
{
    asm volatile("lock\n"
                 "xaddl %0,%1"
                 : "=r" (valueToAdd), "+m" (_q_value)
                 : "0" (valueToAdd)
                 : "memory");
    return valueToAdd;
}

template <typename T>
inline bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
{
    unsigned char ret;
    asm volatile("lock\n"
                 "cmpxchgq %3,%2\n"
                 "sete %1\n"
                 : "=a" (newValue), "=qm" (ret), "+m" (_q_value)
                 : "r" (newValue), "0" (expectedValue)
                 : "memory");
    return ret != 0;
}

template <typename T>
inline T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
{
    asm volatile("xchgq %0,%1"
                 : "=r" (newValue), "+m" (_q_value)
                 : "0" (newValue)
                 : "memory");
    return newValue;
}

template <typename T>
inline T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
{
    asm volatile("lock\n"
                 "xaddq %0,%1"
                 : "=r" (valueToAdd), "+m" (_q_value)
                 : "0" (valueToAdd * sizeof(T))
                 : "memory");
    return reinterpret_cast<T *>(valueToAdd);
}
# 260 "/usr/include/qt4/QtCore/qatomic_x86_64.h"
inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
{
    return testAndSetOrdered(expectedValue, newValue);
}

inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
{
    return testAndSetOrdered(expectedValue, newValue);
}

inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
{
    return testAndSetOrdered(expectedValue, newValue);
}

inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
{
    return fetchAndStoreOrdered(newValue);
}

inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
{
    return fetchAndStoreOrdered(newValue);
}

inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
{
    return fetchAndStoreOrdered(newValue);
}

inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
{
    return fetchAndAddOrdered(valueToAdd);
}

inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
{
    return fetchAndAddOrdered(valueToAdd);
}

inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
{
    return fetchAndAddOrdered(valueToAdd);
}

template <typename T>
inline bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
{
    return testAndSetOrdered(expectedValue, newValue);
}

template <typename T>
inline bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
{
    return testAndSetOrdered(expectedValue, newValue);
}

template <typename T>
inline bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
{
    return testAndSetOrdered(expectedValue, newValue);
}

template <typename T>
inline T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
{
    return fetchAndStoreOrdered(newValue);
}

template <typename T>
inline T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
{
    return fetchAndStoreOrdered(newValue);
}

template <typename T>
inline T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
{
    return fetchAndStoreOrdered(newValue);
}

template <typename T>
inline T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
{
    return fetchAndAddOrdered(valueToAdd);
}

template <typename T>
inline T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
{
    return fetchAndAddOrdered(valueToAdd);
}

template <typename T>
inline T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
{
    return fetchAndAddOrdered(valueToAdd);
}




# 85 "/usr/include/qt4/QtCore/qatomic_arch.h" 2
# 95 "/usr/include/qt4/QtCore/qatomic_arch.h"

# 228 "/usr/include/qt4/QtCore/qbasicatomic.h" 2
# 47 "/usr/include/qt4/QtCore/qatomic.h" 2





typedef QtValidLicenseForCoreModule QtCoreModule;


class QAtomicInt : public QBasicAtomicInt
{
public:
    inline QAtomicInt(int value = 0)
    {



        _q_value = value;
    }
    inline QAtomicInt(const QAtomicInt &other)
    {



        _q_value = other._q_value;
    }

    inline QAtomicInt &operator=(int value)
    {
        (void) QBasicAtomicInt::operator=(value);
        return *this;
    }

    inline QAtomicInt &operator=(const QAtomicInt &other)
    {
        (void) QBasicAtomicInt::operator=(other);
        return *this;
    }
# 121 "/usr/include/qt4/QtCore/qatomic.h"
};


template <typename T>
class QAtomicPointer : public QBasicAtomicPointer<T>
{
public:
    inline QAtomicPointer(T *value = 0)
    {



        QBasicAtomicPointer<T>::_q_value = value;
    }
    inline QAtomicPointer(const QAtomicPointer<T> &other)
    {



        QBasicAtomicPointer<T>::_q_value = other._q_value;
    }

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

    inline QAtomicPointer<T> &operator=(const QAtomicPointer<T> &other)
    {
        (void) QBasicAtomicPointer<T>::operator=(other);
        return *this;
    }
# 186 "/usr/include/qt4/QtCore/qatomic.h"
};







template <typename T>
inline void qAtomicAssign(T *&d, T *x)
{
    if (d == x)
        return;
    x->ref.ref();
    if (!d->ref.deref())
        delete d;
    d = x;
}
# 213 "/usr/include/qt4/QtCore/qatomic.h"
template <typename T>
inline void qAtomicDetach(T *&d)
{
    if (d->ref == 1)
        return;
    T *x = d;
    d = new T(*d);
    if (!x->ref.deref())
        delete x;
}



# 46 "/usr/include/qt4/QtCore/qbytearray.h" 2
# 1 "/usr/include/qt4/QtCore/qnamespace.h" 1
# 47 "/usr/include/qt4/QtCore/qnamespace.h"




typedef QtValidLicenseForCoreModule QtCoreModule;


namespace



Qt {
# 99 "/usr/include/qt4/QtCore/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,
        GroupSwitchModifier = 0x40000000,

        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;
# 168 "/usr/include/qt4/QtCore/qnamespace.h"
    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




    };

    enum TileRule {
        StretchTile,
        RepeatTile,
        RoundTile
    };





    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



    };

    typedef QFlags<AlignmentFlag> Alignment;

    enum TextFlag {
        TextSingleLine = 0x0100,
        TextDontClip = 0x0200,
        TextExpandTabs = 0x0400,
        TextShowMnemonic = 0x0800,
        TextWordWrap = 0x1000,
        TextWrapAnywhere = 0x2000,
        TextDontPrint = 0x4000,
        TextIncludeTrailingSpaces = 0x08000000,
        TextHideMnemonic = 0x8000,
        TextJustificationForced = 0x10000,
        TextForceLeftToRight = 0x20000,
        TextForceRightToLeft = 0x40000,
        TextLongestVariant = 0x80000
# 251 "/usr/include/qt4/QtCore/qnamespace.h"
    };




    enum TextElideMode {
        ElideLeft,
        ElideRight,
        ElideMiddle,
        ElideNone
    };

    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,







        CustomizeWindowHint = 0x02000000,
        WindowStaysOnBottomHint = 0x04000000,
        WindowCloseButtonHint = 0x08000000,
        MacWindowToolBarButtonHint = 0x10000000,
        BypassGraphicsProxyWidget = 0x20000000,
        WindowOkButtonHint = 0x00080000,
        WindowCancelButtonHint = 0x00100000
# 353 "/usr/include/qt4/QtCore/qnamespace.h"
    };

    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_MacBrushedMetal = 46,
        WA_MacMetalStyle = WA_MacBrushedMetal,
        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_AlwaysShowToolTips = 84,
        WA_MacOpaqueSizeGrip = 85,
        WA_SetStyle = 86,

        WA_SetLocale = 87,
        WA_MacShowFocusRect = 88,

        WA_MacNormalSize = 89,
        WA_MacSmallSize = 90,
        WA_MacMiniSize = 91,

        WA_LayoutUsesWidgetRect = 92,
        WA_StyledBackground = 93,
        WA_MSWindowsUseDirect3D = 94,
        WA_CanHostQMdiSubWindowTitleBar = 95,

        WA_MacAlwaysShowToolWindow = 96,

        WA_StyleSheet = 97,

        WA_ShowWithoutActivating = 98,

        WA_X11BypassTransientForHint = 99,

        WA_NativeWindow = 100,
        WA_DontCreateNativeAncestors = 101,

        WA_MacVariableSize = 102,

        WA_DontShowOnScreen = 103,


        WA_X11NetWmWindowTypeDesktop = 104,
        WA_X11NetWmWindowTypeDock = 105,
        WA_X11NetWmWindowTypeToolBar = 106,
        WA_X11NetWmWindowTypeMenu = 107,
        WA_X11NetWmWindowTypeUtility = 108,
        WA_X11NetWmWindowTypeSplash = 109,
        WA_X11NetWmWindowTypeDialog = 110,
        WA_X11NetWmWindowTypeDropDownMenu = 111,
        WA_X11NetWmWindowTypePopupMenu = 112,
        WA_X11NetWmWindowTypeToolTip = 113,
        WA_X11NetWmWindowTypeNotification = 114,
        WA_X11NetWmWindowTypeCombo = 115,
        WA_X11NetWmWindowTypeDND = 116,

        WA_MacFrameworkScaled = 117,

        WA_SetWindowModality = 118,
        WA_WState_WindowOpacitySet = 119,
        WA_TranslucentBackground = 120,

        WA_AcceptTouchEvents = 121,
        WA_WState_AcceptedTouchBeginEvent = 122,
        WA_TouchPadAcceptSingleTouchEvents = 123,

        WA_MergeSoftkeys = 124,
        WA_MergeSoftkeysRecursively = 125,


        WA_AttributeCount
    };

    enum ApplicationAttribute
    {
        AA_ImmediateWidgetCreation = 0,
        AA_MSWindowsUseDirect3DByDefault = 1,
        AA_DontShowIconsInMenus = 2,
        AA_NativeWindows = 3,
        AA_DontCreateNativeWidgetSiblings = 4,
        AA_MacPluginApplication = 5,
        AA_DontUseNativeMenuBar = 6,
        AA_MacDontSwapCtrlAndMeta = 7,
        AA_S60DontConstructApplicationPanes = 8,


        AA_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,

        NoOpaqueDetection = 0x00000100
    };
    typedef QFlags<ImageConversionFlag> ImageConversionFlags;

    enum BGMode {
        TransparentMode,
        OpaqueMode
    };
# 579 "/usr/include/qt4/QtCore/qnamespace.h"
    enum Key {
        Key_Escape = 0x01000000,
        Key_Tab = 0x01000001,
        Key_Backtab = 0x01000002,



        Key_Backspace = 0x01000003,



        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_PageDown = 0x01000017,



        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,
# 822 "/usr/include/qt4/QtCore/qnamespace.h"
        Key_division = 0x0f7,
# 832 "/usr/include/qt4/QtCore/qnamespace.h"
        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,
# 877 "/usr/include/qt4/QtCore/qnamespace.h"
        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_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_MonBrightnessUp = 0x010000b2,
        Key_MonBrightnessDown = 0x010000b3,
        Key_KeyboardLightOnOff = 0x010000b4,
        Key_KeyboardBrightnessUp = 0x010000b5,
        Key_KeyboardBrightnessDown = 0x010000b6,
        Key_PowerOff = 0x010000b7,
        Key_WakeUp = 0x010000b8,
        Key_Eject = 0x010000b9,
        Key_ScreenSaver = 0x010000ba,
        Key_WWW = 0x010000bb,
        Key_Memo = 0x010000bc,
        Key_LightBulb = 0x010000bd,
        Key_Shop = 0x010000be,
        Key_History = 0x010000bf,
        Key_AddFavorite = 0x010000c0,
        Key_HotLinks = 0x010000c1,
        Key_BrightnessAdjust = 0x010000c2,
        Key_Finance = 0x010000c3,
        Key_Community = 0x010000c4,
        Key_AudioRewind = 0x010000c5,
        Key_BackForward = 0x010000c6,
        Key_ApplicationLeft = 0x010000c7,
        Key_ApplicationRight = 0x010000c8,
        Key_Book = 0x010000c9,
        Key_CD = 0x010000ca,
        Key_Calculator = 0x010000cb,
        Key_ToDoList = 0x010000cc,
        Key_ClearGrab = 0x010000cd,
        Key_Close = 0x010000ce,
        Key_Copy = 0x010000cf,
        Key_Cut = 0x010000d0,
        Key_Display = 0x010000d1,
        Key_DOS = 0x010000d2,
        Key_Documents = 0x010000d3,
        Key_Excel = 0x010000d4,
        Key_Explorer = 0x010000d5,
        Key_Game = 0x010000d6,
        Key_Go = 0x010000d7,
        Key_iTouch = 0x010000d8,
        Key_LogOff = 0x010000d9,
        Key_Market = 0x010000da,
        Key_Meeting = 0x010000db,
        Key_MenuKB = 0x010000dc,
        Key_MenuPB = 0x010000dd,
        Key_MySites = 0x010000de,
        Key_News = 0x010000df,
        Key_OfficeHome = 0x010000e0,
        Key_Option = 0x010000e1,
        Key_Paste = 0x010000e2,
        Key_Phone = 0x010000e3,
        Key_Calendar = 0x010000e4,
        Key_Reply = 0x010000e5,
        Key_Reload = 0x010000e6,
        Key_RotateWindows = 0x010000e7,
        Key_RotationPB = 0x010000e8,
        Key_RotationKB = 0x010000e9,
        Key_Save = 0x010000ea,
        Key_Send = 0x010000eb,
        Key_Spell = 0x010000ec,
        Key_SplitScreen = 0x010000ed,
        Key_Support = 0x010000ee,
        Key_TaskPane = 0x010000ef,
        Key_Terminal = 0x010000f0,
        Key_Tools = 0x010000f1,
        Key_Travel = 0x010000f2,
        Key_Video = 0x010000f3,
        Key_Word = 0x010000f4,
        Key_Xfer = 0x010000f5,
        Key_ZoomIn = 0x010000f6,
        Key_ZoomOut = 0x010000f7,
        Key_Away = 0x010000f8,
        Key_Messenger = 0x010000f9,
        Key_WebCam = 0x010000fa,
        Key_MailForward = 0x010000fb,
        Key_Pictures = 0x010000fc,
        Key_Music = 0x010000fd,
        Key_Battery = 0x010000fe,
        Key_Bluetooth = 0x010000ff,
        Key_WLAN = 0x01000100,
        Key_UWB = 0x01000101,
        Key_AudioForward = 0x01000102,
        Key_AudioRepeat = 0x01000103,
        Key_AudioRandomPlay = 0x01000104,
        Key_Subtitle = 0x01000105,
        Key_AudioCycleTrack = 0x01000106,
        Key_Time = 0x01000107,
        Key_Hibernate = 0x01000108,
        Key_View = 0x01000109,
        Key_TopMenu = 0x0100010a,
        Key_PowerDown = 0x0100010b,
        Key_Suspend = 0x0100010c,
        Key_ContrastAdjust = 0x0100010d,

        Key_MediaLast = 0x0100ffff,


        Key_Select = 0x01010000,
        Key_Yes = 0x01010001,
        Key_No = 0x01010002,


        Key_Cancel = 0x01020001,
        Key_Printer = 0x01020002,
        Key_Execute = 0x01020003,
        Key_Sleep = 0x01020004,
        Key_Play = 0x01020005,
        Key_Zoom = 0x01020006,





        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,
        SvgMiterJoin = 0x100,
        MPenJoinStyle = 0x1c0
    };

    enum BrushStyle {
        NoBrush,
        SolidPattern,
        Dense1Pattern,
        Dense2Pattern,
        Dense3Pattern,
        Dense4Pattern,
        Dense5Pattern,
        Dense6Pattern,
        Dense7Pattern,
        HorPattern,
        VerPattern,
        CrossPattern,
        BDiagPattern,
        FDiagPattern,
        DiagCrossPattern,
        LinearGradientPattern,
        RadialGradientPattern,
        ConicalGradientPattern,
        TexturePattern = 24



    };

    enum SizeMode {
        AbsoluteSize,
        RelativeSize
    };
# 1208 "/usr/include/qt4/QtCore/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,
        OpenHandCursor,
        ClosedHandCursor,
        LastCursor = ClosedHandCursor,
        BitmapCursor = 24,
        CustomCursor = 25
# 1261 "/usr/include/qt4/QtCore/qnamespace.h"
    };

    enum TextFormat {
        PlainText,
        RichText,
        AutoText,
        LogText
    };

    enum AspectRatioMode {
        IgnoreAspectRatio,
        KeepAspectRatio,
        KeepAspectRatioByExpanding





    };





    enum AnchorAttribute {
        AnchorName,
        AnchorHref
    };

    enum DockWidgetArea {
        LeftDockWidgetArea = 0x1,
        RightDockWidgetArea = 0x2,
        TopDockWidgetArea = 0x4,
        BottomDockWidgetArea = 0x8,

        DockWidgetArea_Mask = 0xf,
        AllDockWidgetAreas = DockWidgetArea_Mask,
        NoDockWidgetArea = 0
    };
    enum DockWidgetAreaSizes {
        NDockWidgetAreas = 4
    };

    typedef QFlags<DockWidgetArea> DockWidgetAreas;

    enum ToolBarArea {
        LeftToolBarArea = 0x1,
        RightToolBarArea = 0x2,
        TopToolBarArea = 0x4,
        BottomToolBarArea = 0x8,

        ToolBarArea_Mask = 0xf,
        AllToolBarAreas = ToolBarArea_Mask,
        NoToolBarArea = 0
    };

    enum ToolBarAreaSizes {
        NToolBarAreas = 4
    };

    typedef QFlags<ToolBarArea> ToolBarAreas;
# 1345 "/usr/include/qt4/QtCore/qnamespace.h"
    enum DateFormat {
        TextDate,
        ISODate,
        SystemLocaleDate,
        LocalDate = SystemLocaleDate,
        LocaleDate,
        SystemLocaleShortDate,
        SystemLocaleLongDate,
        DefaultLocaleShortDate,
        DefaultLocaleLongDate
    };

    enum TimeSpec {
        LocalTime,
        UTC,
        OffsetFromUTC
    };

    enum DayOfWeek {
        Monday = 1,
        Tuesday = 2,
        Wednesday = 3,
        Thursday = 4,
        Friday = 5,
        Saturday = 6,
        Sunday = 7
    };

    enum ScrollBarPolicy {
        ScrollBarAsNeeded,
        ScrollBarAlwaysOff,
        ScrollBarAlwaysOn
    };
# 1404 "/usr/include/qt4/QtCore/qnamespace.h"
    enum CaseSensitivity {
        CaseInsensitive,
        CaseSensitive
    };

    enum Corner {
        TopLeftCorner = 0x00000,
        TopRightCorner = 0x00001,
        BottomLeftCorner = 0x00002,
        BottomRightCorner = 0x00003






    };

    enum ConnectionType {
        AutoConnection,
        DirectConnection,
        QueuedConnection,
        AutoCompatConnection,
        BlockingQueuedConnection,
        UniqueConnection = 0x80
    };

    enum ShortcutContext {
        WidgetShortcut,
        WindowShortcut,
        ApplicationShortcut,
        WidgetWithChildrenShortcut
    };

    enum FillRule {
        OddEvenFill,
        WindingFill
    };

    enum MaskMode {
        MaskInColor,
        MaskOutColor
    };

    enum ClipOperation {
        NoClip,
        ReplaceClip,
        IntersectClip,
        UniteClip
    };


    enum ItemSelectionMode {
        ContainsItemShape = 0x0,
        IntersectsItemShape = 0x1,
        ContainsItemBoundingRect = 0x2,
        IntersectsItemBoundingRect = 0x3
    };

    enum TransformationMode {
        FastTransformation,
        SmoothTransformation
    };

    enum Axis {
        XAxis,
        YAxis,
        ZAxis
    };

    enum FocusReason {
        MouseFocusReason,
        TabFocusReason,
        BacktabFocusReason,
        ActiveWindowFocusReason,
        PopupFocusReason,
        ShortcutFocusReason,
        MenuBarFocusReason,
        OtherFocusReason,
        NoFocusReason
    };

    enum ContextMenuPolicy {
        NoContextMenu,
        DefaultContextMenu,
        ActionsContextMenu,
        CustomContextMenu,
        PreventContextMenu
    };

    enum InputMethodQuery {
        ImMicroFocus,
        ImFont,
        ImCursorPosition,
        ImSurroundingText,
        ImCurrentSelection,
        ImMaximumTextLength,
        ImAnchorPosition
    };

    enum InputMethodHint {
        ImhNone = 0x0,
        ImhHiddenText = 0x1,
        ImhNoAutoUppercase = 0x2,
        ImhPreferNumbers = 0x4,
        ImhPreferUppercase = 0x8,
        ImhPreferLowercase = 0x10,
        ImhNoPredictiveText = 0x20,

        ImhDigitsOnly = 0x10000,
        ImhFormattedNumbersOnly = 0x20000,
        ImhUppercaseOnly = 0x40000,
        ImhLowercaseOnly = 0x80000,
        ImhDialableCharactersOnly = 0x100000,
        ImhEmailCharactersOnly = 0x200000,
        ImhUrlCharactersOnly = 0x400000,

        ImhExclusiveInputMask = 0xffff0000
    };
    typedef QFlags<InputMethodHint> InputMethodHints;

    enum ToolButtonStyle {
        ToolButtonIconOnly,
        ToolButtonTextOnly,
        ToolButtonTextBesideIcon,
        ToolButtonTextUnderIcon,
        ToolButtonFollowStyle
    };

    enum LayoutDirection {
        LeftToRight,
        RightToLeft
    };

    enum AnchorPoint {
        AnchorLeft = 0,
        AnchorHorizontalCenter,
        AnchorRight,
        AnchorTop,
        AnchorVerticalCenter,
        AnchorBottom
    };



    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,
        BackgroundRole = 8,
        TextColorRole = 9,
        ForegroundRole = 9,
        CheckStateRole = 10,

        AccessibleTextRole = 11,
        AccessibleDescriptionRole = 12,

        SizeHintRole = 13,

        DisplayPropertyRole = 27,
        DecorationPropertyRole = 28,
        ToolTipPropertyRole = 29,
        StatusTipPropertyRole = 30,
        WhatsThisPropertyRole = 31,

        UserRole = 32
    };

    enum ItemFlag {
        NoItemFlags = 0,
        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,
        MatchFixedString = 8,
        MatchCaseSensitive = 16,
        MatchWrap = 32,
        MatchRecursive = 64
    };
    typedef QFlags<MatchFlag> MatchFlags;






    typedef unsigned long HANDLE;





    typedef WindowFlags WFlags;

    enum WindowModality {
        NonModal,
        WindowModal,
        ApplicationModal
    };

    enum TextInteractionFlag {
        NoTextInteraction = 0,
        TextSelectableByMouse = 1,
        TextSelectableByKeyboard = 2,
        LinksAccessibleByMouse = 4,
        LinksAccessibleByKeyboard = 8,
        TextEditable = 16,

        TextEditorInteraction = TextSelectableByMouse | TextSelectableByKeyboard | TextEditable,
        TextBrowserInteraction = TextSelectableByMouse | LinksAccessibleByMouse | LinksAccessibleByKeyboard
    };
    typedef QFlags<TextInteractionFlag> TextInteractionFlags;

    enum EventPriority {
        HighEventPriority = 1,
        NormalEventPriority = 0,
        LowEventPriority = -1
    };

    enum SizeHint {
        MinimumSize,
        PreferredSize,
        MaximumSize,
        MinimumDescent,
        NSizeHints
    };

    enum WindowFrameSection {
        NoSection,
        LeftSection,
        TopLeftSection,
        TopSection,
        TopRightSection,
        RightSection,
        BottomRightSection,
        BottomSection,
        BottomLeftSection,
        TitleBarArea
    };

    enum Initialization {
        Uninitialized
    };

    enum CoordinateSystem {
        DeviceCoordinates,
        LogicalCoordinates
    };

    enum TouchPointState {
        TouchPointPressed = 0x01,
        TouchPointMoved = 0x02,
        TouchPointStationary = 0x04,
        TouchPointReleased = 0x08,
        TouchPointStateMask = 0x0f,

        TouchPointPrimary = 0x10
    };
    typedef QFlags<TouchPointState> TouchPointStates;

    enum GestureState
    {
        NoGesture,
        GestureStarted = 1,
        GestureUpdated = 2,
        GestureFinished = 3,
        GestureCanceled = 4
    };

    enum GestureType
    {
        TapGesture = 1,
        TapAndHoldGesture = 2,
        PanGesture = 3,
        PinchGesture = 4,
        SwipeGesture = 5,

        CustomGesture = 0x0100,

        LastGestureType = ~0u
    };

    enum GestureFlag
    {
        DontStartGestureOnChildren = 0x01,
        ReceivePartialGestures = 0x02
    };
    typedef QFlags<GestureFlag> GestureFlags;

    enum NavigationMode
    {
        NavigationModeNone,
        NavigationModeKeypadTabOrder,
        NavigationModeKeypadDirectional,
        NavigationModeCursorAuto,
        NavigationModeCursorForceVisible
    };
}




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 QIncompatibleFlag operator|(Qt::MouseButtons::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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 QIncompatibleFlag operator|(Qt::Orientations::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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 QIncompatibleFlag operator|(Qt::KeyboardModifiers::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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 QIncompatibleFlag operator|(Qt::WindowFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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 QIncompatibleFlag operator|(Qt::Alignment::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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 QIncompatibleFlag operator|(Qt::ImageConversionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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 QIncompatibleFlag operator|(Qt::DockWidgetAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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 QIncompatibleFlag operator|(Qt::ToolBarAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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 QIncompatibleFlag operator|(Qt::WindowStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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 QIncompatibleFlag operator|(Qt::DropActions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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 QIncompatibleFlag operator|(Qt::ItemFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
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; } inline QIncompatibleFlag operator|(Qt::MatchFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, Qt::TextInteractionFlags::enum_type f2) { return QFlags<Qt::TextInteractionFlags::enum_type>(f1) | f2; } inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, QFlags<Qt::TextInteractionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TextInteractionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
inline QFlags<Qt::InputMethodHints::enum_type> operator|(Qt::InputMethodHints::enum_type f1, Qt::InputMethodHints::enum_type f2) { return QFlags<Qt::InputMethodHints::enum_type>(f1) | f2; } inline QFlags<Qt::InputMethodHints::enum_type> operator|(Qt::InputMethodHints::enum_type f1, QFlags<Qt::InputMethodHints::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::InputMethodHints::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
inline QFlags<Qt::TouchPointStates::enum_type> operator|(Qt::TouchPointStates::enum_type f1, Qt::TouchPointStates::enum_type f2) { return QFlags<Qt::TouchPointStates::enum_type>(f1) | f2; } inline QFlags<Qt::TouchPointStates::enum_type> operator|(Qt::TouchPointStates::enum_type f1, QFlags<Qt::TouchPointStates::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TouchPointStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
inline QFlags<Qt::GestureFlags::enum_type> operator|(Qt::GestureFlags::enum_type f1, Qt::GestureFlags::enum_type f2) { return QFlags<Qt::GestureFlags::enum_type>(f1) | f2; } inline QFlags<Qt::GestureFlags::enum_type> operator|(Qt::GestureFlags::enum_type f1, QFlags<Qt::GestureFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::GestureFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }

typedef bool (*qInternalCallback)(void **);

class QInternal {
public:
    enum PaintDeviceFlags {
        UnknownDevice = 0x00,
        Widget = 0x01,
        Pixmap = 0x02,
        Image = 0x03,
        Printer = 0x04,
        Picture = 0x05,
        Pbuffer = 0x06,
        FramebufferObject = 0x07,
        CustomRaster = 0x08,
        MacQuartz = 0x09,
        PaintBuffer = 0x0a,
        OpenGL = 0x0b
    };
    enum RelayoutType {
        RelayoutNormal,
        RelayoutDragging,
        RelayoutDropped
    };


    enum Callback {
        ConnectCallback,
        DisconnectCallback,
        AdoptCurrentThread,
        EventNotifyCallback,
        LastCallback
    };

    enum InternalFunction {
        CreateThreadForAdoption,
        RefAdoptedThread,
        DerefAdoptedThread,
        SetCurrentThreadToMainThread,
        SetQObjectSender,
        GetQObjectSender,
        ResetQObjectSender,
        LastInternalFunction
    };

    enum DockPosition {
        LeftDock,
        RightDock,
        TopDock,
        BottomDock,
        DockCount
    };

    static bool registerCallback(Callback, qInternalCallback);
    static bool unregisterCallback(Callback, qInternalCallback);

    static bool activateCallbacks(Callback, void **);
    static bool callFunction(InternalFunction func, void **);
};
# 1826 "/usr/include/qt4/QtCore/qnamespace.h"



# 47 "/usr/include/qt4/QtCore/qbytearray.h" 2

# 1 "/usr/include/string.h" 1 3 4
# 26 "/usr/include/string.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 347 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 353 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 354 "/usr/include/sys/cdefs.h" 2 3 4
# 348 "/usr/include/features.h" 2 3 4
# 371 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4



# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 5 "/usr/include/gnu/stubs.h" 2 3 4




# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
# 10 "/usr/include/gnu/stubs.h" 2 3 4
# 372 "/usr/include/features.h" 2 3 4
# 27 "/usr/include/string.h" 2 3 4

extern "C" {




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 34 "/usr/include/string.h" 2 3 4









extern void *memcpy (void *__restrict __dest,
       __const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern void *memmove (void *__dest, __const void *__src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));






extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
        int __c, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __const void *memchr (__const void *__s, int __c, size_t __n)
      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
memchr (void *__s, int __c, size_t __n) throw ()
{
  return __builtin_memchr (__s, __c, __n);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const void *
memchr (__const void *__s, int __c, size_t __n) throw ()
{
  return __builtin_memchr (__s, __c, __n);
}

}










extern "C++" void *rawmemchr (void *__s, int __c)
     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" __const void *rawmemchr (__const void *__s, int __c)
     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));







extern "C++" void *memrchr (void *__s, int __c, size_t __n)
      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" __const void *memrchr (__const void *__s, int __c, size_t __n)
      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));









extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
        __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int strcmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcoll (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
         __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (2)));






# 1 "/usr/include/xlocale.h" 1 3 4
# 28 "/usr/include/xlocale.h" 3 4
typedef struct __locale_struct
{

  struct locale_data *__locales[13];


  const unsigned short int *__ctype_b;
  const int *__ctype_tolower;
  const int *__ctype_toupper;


  const char *__names[13];
} *__locale_t;


typedef __locale_t locale_t;
# 162 "/usr/include/string.h" 2 3 4


extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
    __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));




extern char *strdup (__const char *__s)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));






extern char *strndup (__const char *__string, size_t __n)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 208 "/usr/include/string.h" 3 4



extern "C++"
{
extern char *strchr (char *__s, int __c)
     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __const char *strchr (__const char *__s, int __c)
     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
strchr (char *__s, int __c) throw ()
{
  return __builtin_strchr (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
strchr (__const char *__s, int __c) throw ()
{
  return __builtin_strchr (__s, __c);
}

}






extern "C++"
{
extern char *strrchr (char *__s, int __c)
     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __const char *strrchr (__const char *__s, int __c)
     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
strrchr (char *__s, int __c) throw ()
{
  return __builtin_strrchr (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
strrchr (__const char *__s, int __c) throw ()
{
  return __builtin_strrchr (__s, __c);
}

}










extern "C++" char *strchrnul (char *__s, int __c)
     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" __const char *strchrnul (__const char *__s, int __c)
     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));









extern size_t strcspn (__const char *__s, __const char *__reject)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern size_t strspn (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern "C++"
{
extern char *strpbrk (char *__s, __const char *__accept)
     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern __const char *strpbrk (__const char *__s, __const char *__accept)
     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
strpbrk (char *__s, __const char *__accept) throw ()
{
  return __builtin_strpbrk (__s, __accept);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
strpbrk (__const char *__s, __const char *__accept) throw ()
{
  return __builtin_strpbrk (__s, __accept);
}

}






extern "C++"
{
extern char *strstr (char *__haystack, __const char *__needle)
     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern __const char *strstr (__const char *__haystack,
        __const char *__needle)
     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
strstr (char *__haystack, __const char *__needle) throw ()
{
  return __builtin_strstr (__haystack, __needle);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
strstr (__const char *__haystack, __const char *__needle) throw ()
{
  return __builtin_strstr (__haystack, __needle);
}

}







extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (2)));




extern char *__strtok_r (char *__restrict __s,
    __const char *__restrict __delim,
    char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
         char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));





extern "C++" char *strcasestr (char *__haystack, __const char *__needle)
     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" __const char *strcasestr (__const char *__haystack,
           __const char *__needle)
     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 380 "/usr/include/string.h" 3 4
extern void *memmem (__const void *__haystack, size_t __haystacklen,
       __const void *__needle, size_t __needlelen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));



extern void *__mempcpy (void *__restrict __dest,
   __const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
        __const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern size_t strlen (__const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern size_t strnlen (__const char *__string, size_t __maxlen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strerror (int __errnum) throw ();

# 436 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2)));





extern char *strerror_l (int __errnum, __locale_t __l) throw ();





extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));



extern void bcopy (__const void *__src, void *__dest, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern "C++"
{
extern char *index (char *__s, int __c)
     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __const char *index (__const char *__s, int __c)
     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
index (char *__s, int __c) throw ()
{
  return __builtin_index (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
index (__const char *__s, int __c) throw ()
{
  return __builtin_index (__s, __c);
}

}







extern "C++"
{
extern char *rindex (char *__s, int __c)
     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __const char *rindex (__const char *__s, int __c)
     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
rindex (char *__s, int __c) throw ()
{
  return __builtin_rindex (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
rindex (__const char *__s, int __c) throw ()
{
  return __builtin_rindex (__s, __c);
}

}







extern int ffs (int __i) throw () __attribute__ ((__const__));




extern int ffsl (long int __l) throw () __attribute__ ((__const__));

__extension__ extern int ffsll (long long int __ll)
     throw () __attribute__ ((__const__));




extern int strcasecmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));





extern int strcasecmp_l (__const char *__s1, __const char *__s2,
    __locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern int strncasecmp_l (__const char *__s1, __const char *__s2,
     size_t __n, __locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));





extern char *strsep (char **__restrict __stringp,
       __const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern char *strsignal (int __sig) throw ();


extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern char *__stpncpy (char *__restrict __dest,
   __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
        __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int strverscmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));


extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));







extern "C++" char *basename (char *__filename)
     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" __const char *basename (__const char *__filename)
     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
# 640 "/usr/include/string.h" 3 4
# 1 "/usr/include/bits/string3.h" 1 3 4
# 23 "/usr/include/bits/string3.h" 3 4
extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("memset used with constant zero length parameter; this could be due to transposed parameters")))
                                                                                                   ;
# 48 "/usr/include/bits/string3.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
memcpy (void *__restrict __dest, __const void *__restrict __src, size_t __len) throw ()

{
  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
memmove (void *__restrict __dest, __const void *__restrict __src, size_t __len) throw ()

{
  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
mempcpy (void *__restrict __dest, __const void *__restrict __src, size_t __len) throw ()

{
  return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}
# 77 "/usr/include/bits/string3.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
memset (void *__dest, int __ch, size_t __len) throw ()
{
  if (__builtin_constant_p (__len) && __len == 0
      && (!__builtin_constant_p (__ch) || __ch != 0))
    {
      __warn_memset_zero_len ();
      return __dest;
    }
  return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void
bcopy (__const void *__restrict __src, void *__restrict __dest, size_t __len) throw ()

{
  (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void
bzero (void *__dest, size_t __len) throw ()
{
  (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
strcpy (char *__restrict __dest, __const char *__restrict __src) throw ()
{
  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
stpcpy (char *__restrict __dest, __const char *__restrict __src) throw ()
{
  return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}



extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
strncpy (char *__restrict __dest, __const char *__restrict __src, size_t __len) throw ()

{
  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
}


extern char *__stpncpy_chk (char *__dest, __const char *__src, size_t __n,
       size_t __destlen) throw ();
extern char *__stpncpy_alias (char *__dest, __const char *__src, size_t __n) throw () __asm__ ("" "stpncpy")

                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
stpncpy (char *__dest, __const char *__src, size_t __n) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
      && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
  return __stpncpy_alias (__dest, __src, __n);
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
strcat (char *__restrict __dest, __const char *__restrict __src) throw ()
{
  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
strncat (char *__restrict __dest, __const char *__restrict __src, size_t __len) throw ()

{
  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
}
# 641 "/usr/include/string.h" 2 3 4



}
# 49 "/usr/include/qt4/QtCore/qbytearray.h" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 102 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 50 "/usr/include/qt4/QtCore/qbytearray.h" 2









typedef QtValidLicenseForCoreModule QtCoreModule;





 char *qstrdup(const char *);

inline uint qstrlen(const char *str)
{ return str ? uint(strlen(str)) : 0; }

inline uint qstrnlen(const char *str, uint maxlen)
{
    uint length = 0;
    if (str) {
        while (length < maxlen && *str++)
            length++;
    }
    return length;
}

 char *qstrcpy(char *dst, const char *src);
 char *qstrncpy(char *dst, const char *src, uint len);

 int qstrcmp(const char *str1, const char *str2);
 int qstrcmp(const QByteArray &str1, const QByteArray &str2);
 int qstrcmp(const QByteArray &str1, const char *str2);
static inline int qstrcmp(const char *str1, const QByteArray &str2)
{ return -qstrcmp(str2, str1); }

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, ...);
# 116 "/usr/include/qt4/QtCore/qbytearray.h"
 quint16 qChecksum(const char *s, uint len);

class QByteRef;
class QString;
class QDataStream;
template <typename T> class QList;

class QByteArray
{
private:
    struct Data {
        QBasicAtomicInt ref;
        int alloc, size;



        char *data;
        char array[1];
    };

public:
    inline QByteArray();
    QByteArray(const char *);
    QByteArray(const char *, int size);
    QByteArray(int size, char c);
    QByteArray(int size, Qt::Initialization);
    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();






    char at(int i) const;
    char operator[](int i) const;
    char operator[](uint i) const;

    QByteRef operator[](int i);
    QByteRef operator[](uint i);

    int indexOf(char c, int from = 0) const;
    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;
    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;
# 225 "/usr/include/qt4/QtCore/qbytearray.h"
    QByteArray &prepend(char c);
    QByteArray &prepend(const char *s);
    QByteArray &prepend(const char *s, int len);
    QByteArray &prepend(const QByteArray &a);
    QByteArray &append(char c);
    QByteArray &append(const char *s);
    QByteArray &append(const char *s, int len);
    QByteArray &append(const QByteArray &a);
    QByteArray &insert(int i, char c);
    QByteArray &insert(int i, const char *s);
    QByteArray &insert(int i, const char *s, int len);
    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 char *before, int bsize, const char *after, int asize);
    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;

    QByteArray repeated(int times) const;


    QByteArray &append(const QString &s);
    QByteArray &insert(int i, const QString &s);
    QByteArray &replace(const QString &before, const char *after);
    QByteArray &replace(char c, const QString &after);
    QByteArray &replace(const QString &before, const QByteArray &after);

    QByteArray &operator+=(const QString &s);
    int indexOf(const QString &s, int from = 0) const;
    int lastIndexOf(const QString &s, int from = -1) 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;
    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 toHex() const;
    QByteArray toPercentEncoding(const QByteArray &exclude = QByteArray(),
                                 const QByteArray &include = QByteArray(),
                                 char percent = '%') 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);
    static QByteArray fromHex(const QByteArray &hexEncoded);
    static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent = '%');


    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;
    typedef char value_type;
    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;
# 363 "/usr/include/qt4/QtCore/qbytearray.h"
private:
    operator QNoImplicitBoolCast() const;
    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);
    QByteArray nulTerminated() const;

    friend class QByteRef;
    friend class QString;
    friend QByteArray qUncompress(const uchar *data, int nbytes);
public:
    typedef Data * DataPtr;
    inline DataPtr &data_ptr() { return d; }
};

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; }
# 394 "/usr/include/qt4/QtCore/qbytearray.h"
inline char QByteArray::at(int i) const
{ ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","/usr/include/qt4/QtCore/qbytearray.h",395) : qt_noop()); return d->data[i]; }
inline char QByteArray::operator[](int i) const
{ ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","/usr/include/qt4/QtCore/qbytearray.h",397) : qt_noop()); return d->data[i]; }
inline char QByteArray::operator[](uint i) const
{ ((!(i < uint(size()))) ? qt_assert("i < uint(size())","/usr/include/qt4/QtCore/qbytearray.h",399) : qt_noop()); 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 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 char() const
        { return i < a.d->size ? a.d->data[i] : char(0); }

    inline QByteRef &operator=(char c)
        { if (i >= a.d->size) a.expand(i); else a.detach();
          a.d->data[i] = c; return *this; }
    inline QByteRef &operator=(const QByteRef &c)
        { if (i >= a.d->size) a.expand(i); else a.detach();
          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)
{ ((!(i >= 0)) ? qt_assert("i >= 0","/usr/include/qt4/QtCore/qbytearray.h",471) : qt_noop()); 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.constData(), a2.constData(), a1.size())==0); }
inline bool operator==(const QByteArray &a1, const char *a2)
{ return a2 ? qstrcmp(a1,a2) == 0 : a1.isEmpty(); }
inline bool operator==(const char *a1, const QByteArray &a2)
{ return a1 ? qstrcmp(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 ? qstrcmp(a1,a2) != 0 : !a1.isEmpty(); }
inline bool operator!=(const char *a1, const QByteArray &a2)
{ return a1 ? qstrcmp(a1,a2) != 0 : !a2.isEmpty(); }
inline bool operator<(const QByteArray &a1, const QByteArray &a2)
{ return qstrcmp(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 qstrcmp(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 qstrcmp(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 qstrcmp(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 QBool QByteArray::contains(const char *c) const
{ return QBool(indexOf(c) != -1); }
inline QByteArray &QByteArray::replace(char before, const char *c)
{ return replace(&before, 1, c, qstrlen(c)); }
inline QByteArray &QByteArray::replace(const QByteArray &before, const char *c)
{ return replace(before.constData(), before.size(), c, qstrlen(c)); }
inline QByteArray &QByteArray::replace(const char *before, const char *after)
{ return replace(before, qstrlen(before), 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(); } template <> inline void qSwap<QByteArray>(QByteArray &value1, QByteArray &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }




# 47 "/usr/include/qt4/QtCore/qstring.h" 2
# 60 "/usr/include/qt4/QtCore/qstring.h"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 3
       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 1 3
# 275 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3
# 276 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3
# 279 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stringfwd.h" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stringfwd.h" 3
       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stringfwd.h" 3



namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _Alloc>
    class allocator;

  template<class _CharT>
    struct char_traits;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
    class basic_string;

  template<> struct char_traits<char>;

  typedef basic_string<char> string;


  template<> struct char_traits<wchar_t>;

  typedef basic_string<wchar_t> wstring;
# 75 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stringfwd.h" 3
}
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 1 3
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3




namespace std __attribute__ ((__visibility__ ("default"))) {

  using ::ptrdiff_t;
  using ::size_t;

}
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/functexcept.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/functexcept.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception_defines.h" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/functexcept.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {


  void
  __throw_bad_exception(void) __attribute__((__noreturn__));


  void
  __throw_bad_alloc(void) __attribute__((__noreturn__));


  void
  __throw_bad_cast(void) __attribute__((__noreturn__));

  void
  __throw_bad_typeid(void) __attribute__((__noreturn__));


  void
  __throw_logic_error(const char*) __attribute__((__noreturn__));

  void
  __throw_domain_error(const char*) __attribute__((__noreturn__));

  void
  __throw_invalid_argument(const char*) __attribute__((__noreturn__));

  void
  __throw_length_error(const char*) __attribute__((__noreturn__));

  void
  __throw_out_of_range(const char*) __attribute__((__noreturn__));

  void
  __throw_runtime_error(const char*) __attribute__((__noreturn__));

  void
  __throw_range_error(const char*) __attribute__((__noreturn__));

  void
  __throw_overflow_error(const char*) __attribute__((__noreturn__));

  void
  __throw_underflow_error(const char*) __attribute__((__noreturn__));


  void
  __throw_ios_failure(const char*) __attribute__((__noreturn__));

  void
  __throw_system_error(int) __attribute__((__noreturn__));

  void
  __throw_future_error(int) __attribute__((__noreturn__));


  void
  __throw_bad_function_call() __attribute__((__noreturn__));

}
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 3
       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 3
# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {

  template<typename _Iterator, typename _Container>
    class __normal_iterator;

}

namespace std __attribute__ ((__visibility__ ("default"))) {

  struct __true_type { };
  struct __false_type { };

  template<bool>
    struct __truth_type
    { typedef __false_type __type; };

  template<>
    struct __truth_type<true>
    { typedef __true_type __type; };



  template<class _Sp, class _Tp>
    struct __traitor
    {
      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
      typedef typename __truth_type<__value>::__type __type;
    };


  template<typename, typename>
    struct __are_same
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<typename _Tp>
    struct __are_same<_Tp, _Tp>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };


  template<typename _Tp>
    struct __is_void
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<>
    struct __is_void<void>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_integer
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };




  template<>
    struct __is_integer<bool>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<signed char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };


  template<>
    struct __is_integer<wchar_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# 194 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 3
  template<>
    struct __is_integer<short>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned short>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<int>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned int>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_floating
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };


  template<>
    struct __is_floating<float>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_floating<double>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_floating<long double>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_pointer
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<typename _Tp>
    struct __is_pointer<_Tp*>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_normal_iterator
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<typename _Iterator, typename _Container>
    struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
             _Container> >
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_arithmetic
    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
    { };




  template<typename _Tp>
    struct __is_fundamental
    : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
    { };




  template<typename _Tp>
    struct __is_scalar
    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
    { };




  template<typename _Tp>
    struct __is_char
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<>
    struct __is_char<char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };


  template<>
    struct __is_char<wchar_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };


  template<typename _Tp>
    struct __is_byte
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<>
    struct __is_byte<char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_byte<signed char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_byte<unsigned char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_move_iterator
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 3
}
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/type_traits.h" 1 3
# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/type_traits.h" 3
       
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/type_traits.h" 3




namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {


  template<bool, typename>
    struct __enable_if
    { };

  template<typename _Tp>
    struct __enable_if<true, _Tp>
    { typedef _Tp __type; };



  template<bool _Cond, typename _Iftrue, typename _Iffalse>
    struct __conditional_type
    { typedef _Iftrue __type; };

  template<typename _Iftrue, typename _Iffalse>
    struct __conditional_type<false, _Iftrue, _Iffalse>
    { typedef _Iffalse __type; };



  template<typename _Tp>
    struct __add_unsigned
    {
    private:
      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;

    public:
      typedef typename __if_type::__type __type;
    };

  template<>
    struct __add_unsigned<char>
    { typedef unsigned char __type; };

  template<>
    struct __add_unsigned<signed char>
    { typedef unsigned char __type; };

  template<>
    struct __add_unsigned<short>
    { typedef unsigned short __type; };

  template<>
    struct __add_unsigned<int>
    { typedef unsigned int __type; };

  template<>
    struct __add_unsigned<long>
    { typedef unsigned long __type; };

  template<>
    struct __add_unsigned<long long>
    { typedef unsigned long long __type; };


  template<>
    struct __add_unsigned<bool>;

  template<>
    struct __add_unsigned<wchar_t>;



  template<typename _Tp>
    struct __remove_unsigned
    {
    private:
      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;

    public:
      typedef typename __if_type::__type __type;
    };

  template<>
    struct __remove_unsigned<char>
    { typedef signed char __type; };

  template<>
    struct __remove_unsigned<unsigned char>
    { typedef signed char __type; };

  template<>
    struct __remove_unsigned<unsigned short>
    { typedef short __type; };

  template<>
    struct __remove_unsigned<unsigned int>
    { typedef int __type; };

  template<>
    struct __remove_unsigned<unsigned long>
    { typedef long __type; };

  template<>
    struct __remove_unsigned<unsigned long long>
    { typedef long long __type; };


  template<>
    struct __remove_unsigned<bool>;

  template<>
    struct __remove_unsigned<wchar_t>;



  template<typename _Type>
    inline bool
    __is_null_pointer(_Type* __ptr)
    { return __ptr == 0; }

  template<typename _Type>
    inline bool
    __is_null_pointer(_Type)
    { return false; }



  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
    struct __promote
    { typedef double __type; };

  template<typename _Tp>
    struct __promote<_Tp, false>
    { typedef _Tp __type; };

  template<typename _Tp, typename _Up>
    struct __promote_2
    {
    private:
      typedef typename __promote<_Tp>::__type __type1;
      typedef typename __promote<_Up>::__type __type2;

    public:
      typedef __typeof__(__type1() + __type2()) __type;
    };

  template<typename _Tp, typename _Up, typename _Vp>
    struct __promote_3
    {
    private:
      typedef typename __promote<_Tp>::__type __type1;
      typedef typename __promote<_Up>::__type __type2;
      typedef typename __promote<_Vp>::__type __type3;

    public:
      typedef __typeof__(__type1() + __type2() + __type3()) __type;
    };

  template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
    struct __promote_4
    {
    private:
      typedef typename __promote<_Tp>::__type __type1;
      typedef typename __promote<_Up>::__type __type2;
      typedef typename __promote<_Vp>::__type __type3;
      typedef typename __promote<_Wp>::__type __type4;

    public:
      typedef __typeof__(__type1() + __type2() + __type3() + __type4()) __type;
    };

}
# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/numeric_traits.h" 1 3
# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/numeric_traits.h" 3
       
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/numeric_traits.h" 3




namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/numeric_traits.h" 3
  template<typename _Value>
    struct __numeric_traits_integer
    {

      static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);



      static const bool __is_signed = ((_Value)(-1) < 0);
      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
    };

  template<typename _Value>
    const _Value __numeric_traits_integer<_Value>::__min;

  template<typename _Value>
    const _Value __numeric_traits_integer<_Value>::__max;

  template<typename _Value>
    const bool __numeric_traits_integer<_Value>::__is_signed;

  template<typename _Value>
    const int __numeric_traits_integer<_Value>::__digits;
# 97 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/numeric_traits.h" 3
  template<typename _Value>
    struct __numeric_traits_floating
    {

      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 3010 / 10000);


      static const bool __is_signed = true;
      static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
    };

  template<typename _Value>
    const int __numeric_traits_floating<_Value>::__max_digits10;

  template<typename _Value>
    const bool __numeric_traits_floating<_Value>::__is_signed;

  template<typename _Value>
    const int __numeric_traits_floating<_Value>::__digits10;

  template<typename _Value>
    const int __numeric_traits_floating<_Value>::__max_exponent10;

  template<typename _Value>
    struct __numeric_traits
    : public __conditional_type<std::__is_integer<_Value>::__value,
    __numeric_traits_integer<_Value>,
    __numeric_traits_floating<_Value> >::__type
    { };

}
# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 1 3
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/concept_check.h" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/concept_check.h" 3
       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/concept_check.h" 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 2 3
# 95 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 3
  template<typename _Tp>
    inline void
    swap(_Tp& __a, _Tp& __b)
    {

     

      _Tp __tmp = (__a);
      __a = (__b);
      __b = (__tmp);
    }



  template<typename _Tp, size_t _Nm>
    inline void
    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
    {
      for (size_t __n = 0; __n < _Nm; ++__n)
 swap(__a[__n], __b[__n]);
    }

}
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 2 3






namespace std __attribute__ ((__visibility__ ("default"))) {


  template<class _T1, class _T2>
    struct pair
    {
      typedef _T1 first_type;
      typedef _T2 second_type;

      _T1 first;
      _T2 second;





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


      pair(const _T1& __a, const _T2& __b)
      : first(__a), second(__b) { }
# 117 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 3
      template<class _U1, class _U2>
        pair(const pair<_U1, _U2>& __p)
 : first(__p.first),
   second(__p.second) { }
# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 3
    };


  template<class _T1, class _T2>
    inline bool
    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __x.first == __y.first && __x.second == __y.second; }


  template<class _T1, class _T2>
    inline bool
    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __x.first < __y.first
      || (!(__y.first < __x.first) && __x.second < __y.second); }


  template<class _T1, class _T2>
    inline bool
    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__x == __y); }


  template<class _T1, class _T2>
    inline bool
    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __y < __x; }


  template<class _T1, class _T2>
    inline bool
    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__y < __x); }


  template<class _T1, class _T2>
    inline bool
    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__x < __y); }
# 215 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 3
  template<class _T1, class _T2>
    inline pair<_T1, _T2>
    make_pair(_T1 __x, _T2 __y)
    { return pair<_T1, _T2>(__x, __y); }
# 261 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 3
}
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 1 3
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 3
       
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 3
  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 { };
# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 3
  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
           typename _Pointer = _Tp*, typename _Reference = _Tp&>
    struct iterator
    {

      typedef _Category iterator_category;

      typedef _Tp value_type;

      typedef _Distance difference_type;

      typedef _Pointer pointer;

      typedef _Reference reference;
    };
# 130 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 3
  template<typename _Iterator>
    struct iterator_traits
    {
      typedef typename _Iterator::iterator_category iterator_category;
      typedef typename _Iterator::value_type value_type;
      typedef typename _Iterator::difference_type difference_type;
      typedef typename _Iterator::pointer pointer;
      typedef typename _Iterator::reference reference;
    };


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


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





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



}
# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 1 3
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
       
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 3


namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _InputIterator>
    inline typename iterator_traits<_InputIterator>::difference_type
    __distance(_InputIterator __first, _InputIterator __last,
               input_iterator_tag)
    {

     

      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      while (__first != __last)
 {
   ++__first;
   ++__n;
 }
      return __n;
    }

  template<typename _RandomAccessIterator>
    inline typename iterator_traits<_RandomAccessIterator>::difference_type
    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
               random_access_iterator_tag)
    {

     

      return __last - __first;
    }
# 108 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator>
    inline typename iterator_traits<_InputIterator>::difference_type
    distance(_InputIterator __first, _InputIterator __last)
    {

      return std::__distance(__first, __last,
        std::__iterator_category(__first));
    }

  template<typename _InputIterator, typename _Distance>
    inline void
    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
    {

     
      while (__n--)
 ++__i;
    }

  template<typename _BidirectionalIterator, typename _Distance>
    inline void
    __advance(_BidirectionalIterator& __i, _Distance __n,
       bidirectional_iterator_tag)
    {

     

      if (__n > 0)
        while (__n--)
   ++__i;
      else
        while (__n++)
   --__i;
    }

  template<typename _RandomAccessIterator, typename _Distance>
    inline void
    __advance(_RandomAccessIterator& __i, _Distance __n,
              random_access_iterator_tag)
    {

     

      __i += __n;
    }
# 166 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator, typename _Distance>
    inline void
    advance(_InputIterator& __i, _Distance __n)
    {

      typename iterator_traits<_InputIterator>::difference_type __d = __n;
      std::__advance(__i, __d, std::__iterator_category(__i));
    }
# 195 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
}
# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 1 3
# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 94 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Iterator>
    class reverse_iterator
    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
        typename iterator_traits<_Iterator>::value_type,
        typename iterator_traits<_Iterator>::difference_type,
        typename iterator_traits<_Iterator>::pointer,
                      typename iterator_traits<_Iterator>::reference>
    {
    public:
      _Iterator current;

      typedef iterator_traits<_Iterator> __traits_type;

    public:
      typedef _Iterator iterator_type;
      typedef typename __traits_type::difference_type difference_type;
      typedef typename __traits_type::pointer pointer;
      typedef typename __traits_type::reference reference;







      reverse_iterator() : current() { }




      explicit
      reverse_iterator(iterator_type __x) : current(__x) { }




      reverse_iterator(const reverse_iterator& __x)
      : current(__x.current) { }





      template<typename _Iter>
        reverse_iterator(const reverse_iterator<_Iter>& __x)
 : current(__x.base()) { }




      iterator_type
      base() const
      { return current; }






      reference
      operator*() const
      {
 _Iterator __tmp = current;
 return *--__tmp;
      }






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






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






      reverse_iterator
      operator++(int)
      {
 reverse_iterator __tmp = *this;
 --current;
 return __tmp;
      }






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






      reverse_iterator
      operator--(int)
      {
 reverse_iterator __tmp = *this;
 ++current;
 return __tmp;
      }






      reverse_iterator
      operator+(difference_type __n) const
      { return reverse_iterator(current - __n); }






      reverse_iterator&
      operator+=(difference_type __n)
      {
 current -= __n;
 return *this;
      }






      reverse_iterator
      operator-(difference_type __n) const
      { return reverse_iterator(current + __n); }






      reverse_iterator&
      operator-=(difference_type __n)
      {
 current += __n;
 return *this;
      }






      reference
      operator[](difference_type __n) const
      { return *(*this + __n); }
    };
# 281 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Iterator>
    inline bool
    operator==(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    { return __x.base() == __y.base(); }

  template<typename _Iterator>
    inline bool
    operator<(const reverse_iterator<_Iterator>& __x,
       const reverse_iterator<_Iterator>& __y)
    { return __y.base() < __x.base(); }

  template<typename _Iterator>
    inline bool
    operator!=(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    { return !(__x == __y); }

  template<typename _Iterator>
    inline bool
    operator>(const reverse_iterator<_Iterator>& __x,
       const reverse_iterator<_Iterator>& __y)
    { return __y < __x; }

  template<typename _Iterator>
    inline bool
    operator<=(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    { return !(__y < __x); }

  template<typename _Iterator>
    inline bool
    operator>=(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    { return !(__x < __y); }

  template<typename _Iterator>
    inline typename reverse_iterator<_Iterator>::difference_type
    operator-(const reverse_iterator<_Iterator>& __x,
       const reverse_iterator<_Iterator>& __y)
    { return __y.base() - __x.base(); }

  template<typename _Iterator>
    inline reverse_iterator<_Iterator>
    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
       const reverse_iterator<_Iterator>& __x)
    { return reverse_iterator<_Iterator>(__x.base() - __n); }



  template<typename _IteratorL, typename _IteratorR>
    inline bool
    operator==(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    { return __x.base() == __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    inline bool
    operator<(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    { return __y.base() < __x.base(); }

  template<typename _IteratorL, typename _IteratorR>
    inline bool
    operator!=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    { return !(__x == __y); }

  template<typename _IteratorL, typename _IteratorR>
    inline bool
    operator>(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    { return __y < __x; }

  template<typename _IteratorL, typename _IteratorR>
    inline bool
    operator<=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    { return !(__y < __x); }

  template<typename _IteratorL, typename _IteratorR>
    inline bool
    operator>=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    { return !(__x < __y); }

  template<typename _IteratorL, typename _IteratorR>







    inline typename reverse_iterator<_IteratorL>::difference_type
    operator-(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)

    { return __y.base() - __x.base(); }
# 393 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Container>
    class back_insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:
      _Container* container;

    public:

      typedef _Container container_type;


      explicit
      back_insert_iterator(_Container& __x) : container(&__x) { }
# 419 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
      back_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 container->push_back(__value);
 return *this;
      }
# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
      back_insert_iterator&
      operator*()
      { return *this; }


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


      back_insert_iterator
      operator++(int)
      { return *this; }
    };
# 462 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Container>
    inline back_insert_iterator<_Container>
    back_inserter(_Container& __x)
    { return back_insert_iterator<_Container>(__x); }
# 477 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Container>
    class front_insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:
      _Container* container;

    public:

      typedef _Container container_type;


      explicit front_insert_iterator(_Container& __x) : container(&__x) { }
# 502 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
      front_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 container->push_front(__value);
 return *this;
      }
# 519 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
      front_insert_iterator&
      operator*()
      { return *this; }


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


      front_insert_iterator
      operator++(int)
      { return *this; }
    };
# 545 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Container>
    inline front_insert_iterator<_Container>
    front_inserter(_Container& __x)
    { return front_insert_iterator<_Container>(__x); }
# 564 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Container>
    class insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:
      _Container* container;
      typename _Container::iterator iter;

    public:

      typedef _Container container_type;





      insert_iterator(_Container& __x, typename _Container::iterator __i)
      : container(&__x), iter(__i) {}
# 606 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
      insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 iter = container->insert(iter, __value);
 ++iter;
 return *this;
      }
# 625 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
      insert_iterator&
      operator*()
      { return *this; }


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


      insert_iterator&
      operator++(int)
      { return *this; }
    };
# 651 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Container, typename _Iterator>
    inline insert_iterator<_Container>
    inserter(_Container& __x, _Iterator __i)
    {
      return insert_iterator<_Container>(__x,
      typename _Container::iterator(__i));
    }



}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
    {
    public:
      _Iterator _M_current;

      typedef iterator_traits<_Iterator> __traits_type;

    public:
      typedef _Iterator iterator_type;
      typedef typename __traits_type::iterator_category iterator_category;
      typedef typename __traits_type::value_type value_type;
      typedef typename __traits_type::difference_type difference_type;
      typedef typename __traits_type::reference reference;
      typedef typename __traits_type::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }


      template<typename _Iter>
        __normal_iterator(const __normal_iterator<_Iter,
     typename __enable_if<
              (std::__are_same<_Iter, typename _Container::pointer>::__value),
        _Container>::__type>& __i)
        : _M_current(__i.base()) { }


      reference
      operator*() const
      { return *_M_current; }

      pointer
      operator->() const
      { return _M_current; }

      __normal_iterator&
      operator++()
      {
 ++_M_current;
 return *this;
      }

      __normal_iterator
      operator++(int)
      { return __normal_iterator(_M_current++); }


      __normal_iterator&
      operator--()
      {
 --_M_current;
 return *this;
      }

      __normal_iterator
      operator--(int)
      { return __normal_iterator(_M_current--); }


      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const
      { return _M_current; }
    };
# 770 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() != __rhs.base(); }


  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() >= __rhs.base(); }





  template<typename _IteratorL, typename _IteratorR, typename _Container>







    inline typename __normal_iterator<_IteratorL, _Container>::difference_type
    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs)

    { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline typename __normal_iterator<_Iterator, _Container>::difference_type
    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline __normal_iterator<_Iterator, _Container>
    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
       __n, const __normal_iterator<_Iterator, _Container>& __i)
    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

}
# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/debug/debug.h" 1 3
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/debug/debug.h" 3
namespace std
{
  namespace __debug { }
}




namespace __gnu_debug
{
  using namespace std::__debug;
}
# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3


namespace std __attribute__ ((__visibility__ ("default"))) {




  template<bool _BoolType>
    struct __iter_swap
    {
      template<typename _ForwardIterator1, typename _ForwardIterator2>
        static void
        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
        {
          typedef typename iterator_traits<_ForwardIterator1>::value_type
            _ValueType1;
          _ValueType1 __tmp = (*__a);
          *__a = (*__b);
          *__b = (__tmp);
 }
    };

  template<>
    struct __iter_swap<true>
    {
      template<typename _ForwardIterator1, typename _ForwardIterator2>
        static void
        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
        {
          swap(*__a, *__b);
        }
    };
# 115 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    inline void
    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
    {
      typedef typename iterator_traits<_ForwardIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_ForwardIterator2>::value_type
 _ValueType2;


     

     

     

     


      typedef typename iterator_traits<_ForwardIterator1>::reference
 _ReferenceType1;
      typedef typename iterator_traits<_ForwardIterator2>::reference
 _ReferenceType2;
      std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value
 && __are_same<_ValueType1&, _ReferenceType1>::__value
 && __are_same<_ValueType2&, _ReferenceType2>::__value>::
 iter_swap(__a, __b);
    }
# 156 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    _ForwardIterator2
    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2)
    {

     

     

      ;

      for (; __first1 != __last1; ++__first1, ++__first2)
 std::iter_swap(__first1, __first2);
      return __first2;
    }
# 184 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _Tp>
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b)
    {

     

      if (__b < __a)
 return __b;
      return __a;
    }
# 207 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _Tp>
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b)
    {

     

      if (__a < __b)
 return __b;
      return __a;
    }
# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__b, __a))
 return __b;
      return __a;
    }
# 251 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__a, __b))
 return __b;
      return __a;
    }




  template<typename _Iterator, bool _HasBase>
    struct _Iter_base
    {
      typedef _Iterator iterator_type;
      static iterator_type
      _S_base(_Iterator __it)
      { return __it; }
    };

  template<typename _Iterator>
    struct _Iter_base<_Iterator, true>
    {
      typedef typename _Iterator::iterator_type iterator_type;
      static iterator_type
      _S_base(_Iterator __it)
      { return __it.base(); }
    };



  template<typename _Iterator>
    struct _Niter_base
    : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
    { };

  template<typename _Iterator>
    inline typename _Niter_base<_Iterator>::iterator_type
    __niter_base(_Iterator __it)
    { return std::_Niter_base<_Iterator>::_S_base(__it); }


  template<typename _Iterator>
    struct _Miter_base
    : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
    { };

  template<typename _Iterator>
    inline typename _Miter_base<_Iterator>::iterator_type
    __miter_base(_Iterator __it)
    { return std::_Miter_base<_Iterator>::_S_base(__it); }







  template<bool, bool, typename>
    struct __copy_move
    {
      template<typename _II, typename _OI>
        static _OI
        __copy_m(_II __first, _II __last, _OI __result)
        {
   for (; __first != __last; ++__result, ++__first)
     *__result = *__first;
   return __result;
 }
    };
# 339 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<>
    struct __copy_move<false, false, random_access_iterator_tag>
    {
      template<typename _II, typename _OI>
        static _OI
        __copy_m(_II __first, _II __last, _OI __result)
        {
   typedef typename iterator_traits<_II>::difference_type _Distance;
   for(_Distance __n = __last - __first; __n > 0; --__n)
     {
       *__result = *__first;
       ++__first;
       ++__result;
     }
   return __result;
 }
    };
# 377 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<bool _IsMove>
    struct __copy_move<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp>
        static _Tp*
        __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
        {
   const ptrdiff_t _Num = __last - __first;
   if (_Num)
     __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
   return __result + _Num;
 }
    };

  template<bool _IsMove, typename _II, typename _OI>
    inline _OI
    __copy_move_a(_II __first, _II __last, _OI __result)
    {
      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
      typedef typename iterator_traits<_II>::iterator_category _Category;
      const bool __simple = (__is_pod(_ValueTypeI)
                      && __is_pointer<_II>::__value
                      && __is_pointer<_OI>::__value
        && __are_same<_ValueTypeI, _ValueTypeO>::__value);

      return std::__copy_move<_IsMove, __simple,
                       _Category>::__copy_m(__first, __last, __result);
    }



  template<typename _CharT>
    struct char_traits;

  template<typename _CharT, typename _Traits>
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator;

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(_CharT*, _CharT*,
     ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(const _CharT*, const _CharT*,
     ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);

  template<bool _IsMove, typename _II, typename _OI>
    inline _OI
    __copy_move_a2(_II __first, _II __last, _OI __result)
    {
      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
          std::__niter_base(__last),
          std::__niter_base(__result)));
    }
# 462 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _II, typename _OI>
    inline _OI
    copy(_II __first, _II __last, _OI __result)
    {

     
     

      ;

      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
       (std::__miter_base(__first), std::__miter_base(__last),
        __result));
    }
# 514 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<bool, bool, typename>
    struct __copy_move_backward
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
        {
   while (__first != __last)
     *--__result = *--__last;
   return __result;
 }
    };
# 542 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<>
    struct __copy_move_backward<false, false, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
        {
   typename iterator_traits<_BI1>::difference_type __n;
   for (__n = __last - __first; __n > 0; --__n)
     *--__result = *--__last;
   return __result;
 }
    };
# 572 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<bool _IsMove>
    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp>
        static _Tp*
        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
        {
   const ptrdiff_t _Num = __last - __first;
   if (_Num)
     __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
   return __result - _Num;
 }
    };

  template<bool _IsMove, typename _BI1, typename _BI2>
    inline _BI2
    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
      typedef typename iterator_traits<_BI1>::iterator_category _Category;
      const bool __simple = (__is_pod(_ValueType1)
                      && __is_pointer<_BI1>::__value
                      && __is_pointer<_BI2>::__value
        && __are_same<_ValueType1, _ValueType2>::__value);

      return std::__copy_move_backward<_IsMove, __simple,
                                _Category>::__copy_move_b(__first,
         __last,
         __result);
    }

  template<bool _IsMove, typename _BI1, typename _BI2>
    inline _BI2
    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      return _BI2(std::__copy_move_backward_a<_IsMove>
    (std::__niter_base(__first), std::__niter_base(__last),
     std::__niter_base(__result)));
    }
# 631 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _BI1, typename _BI2>
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {

     
     
     


      ;

      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
       (std::__miter_base(__first), std::__miter_base(__last),
        __result));
    }
# 689 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
       const _Tp& __value)
    {
      for (; __first != __last; ++__first)
 *__first = __value;
    }

  template<typename _ForwardIterator, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (; __first != __last; ++__first)
 *__first = __tmp;
    }


  template<typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
    {
      const _Tp __tmp = __c;
      __builtin_memset(__first, static_cast<unsigned char>(__tmp),
         __last - __first);
    }
# 733 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline void
    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
    {

     

      ;

      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
      __value);
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      for (; __n > 0; --__n, ++__first)
 *__first = __value;
      return __first;
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (; __n > 0; --__n, ++__first)
 *__first = __tmp;
      return __first;
    }

  template<typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
    {
      std::__fill_a(__first, __first + __n, __c);
      return __first + __n;
    }
# 791 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _OI, typename _Size, typename _Tp>
    inline _OI
    fill_n(_OI __first, _Size __n, const _Tp& __value)
    {

     

      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
    }

  template<bool _BoolType>
    struct __equal
    {
      template<typename _II1, typename _II2>
        static bool
        equal(_II1 __first1, _II1 __last1, _II2 __first2)
        {
   for (; __first1 != __last1; ++__first1, ++__first2)
     if (!(*__first1 == *__first2))
       return false;
   return true;
 }
    };

  template<>
    struct __equal<true>
    {
      template<typename _Tp>
        static bool
        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
        {
   return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
       * (__last1 - __first1));
 }
    };

  template<typename _II1, typename _II2>
    inline bool
    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple = (__is_integer<_ValueType1>::__value
                      && __is_pointer<_II1>::__value
                      && __is_pointer<_II2>::__value
        && __are_same<_ValueType1, _ValueType2>::__value);

      return std::__equal<__simple>::equal(__first1, __last1, __first2);
    }


  template<typename, typename>
    struct __lc_rai
    {
      template<typename _II1, typename _II2>
        static _II1
        __newlast1(_II1, _II1 __last1, _II2, _II2)
        { return __last1; }

      template<typename _II>
        static bool
        __cnd2(_II __first, _II __last)
        { return __first != __last; }
    };

  template<>
    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
    {
      template<typename _RAI1, typename _RAI2>
        static _RAI1
        __newlast1(_RAI1 __first1, _RAI1 __last1,
     _RAI2 __first2, _RAI2 __last2)
        {
   const typename iterator_traits<_RAI1>::difference_type
     __diff1 = __last1 - __first1;
   const typename iterator_traits<_RAI2>::difference_type
     __diff2 = __last2 - __first2;
   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
 }

      template<typename _RAI>
        static bool
        __cnd2(_RAI, _RAI)
        { return true; }
    };

  template<bool _BoolType>
    struct __lexicographical_compare
    {
      template<typename _II1, typename _II2>
        static bool __lc(_II1, _II1, _II2, _II2);
    };

  template<bool _BoolType>
    template<typename _II1, typename _II2>
      bool
      __lexicographical_compare<_BoolType>::
      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
      {
 typedef typename iterator_traits<_II1>::iterator_category _Category1;
 typedef typename iterator_traits<_II2>::iterator_category _Category2;
 typedef std::__lc_rai<_Category1, _Category2> __rai_type;

 __last1 = __rai_type::__newlast1(__first1, __last1,
      __first2, __last2);
 for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
      ++__first1, ++__first2)
   {
     if (*__first1 < *__first2)
       return true;
     if (*__first2 < *__first1)
       return false;
   }
 return __first1 == __last1 && __first2 != __last2;
      }

  template<>
    struct __lexicographical_compare<true>
    {
      template<typename _Tp, typename _Up>
        static bool
        __lc(const _Tp* __first1, const _Tp* __last1,
      const _Up* __first2, const _Up* __last2)
 {
   const size_t __len1 = __last1 - __first1;
   const size_t __len2 = __last2 - __first2;
   const int __result = __builtin_memcmp(__first1, __first2,
      std::min(__len1, __len2));
   return __result != 0 ? __result < 0 : __len1 < __len2;
 }
    };

  template<typename _II1, typename _II2>
    inline bool
    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
      _II2 __first2, _II2 __last2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple =
 (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
  && __is_pointer<_II1>::__value
  && __is_pointer<_II2>::__value);

      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
           __first2, __last2);
    }
# 952 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;


     
     
      ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (*__middle < __val)
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }



  template<typename _Size>
    inline _Size
    __lg(_Size __n)
    {
      _Size __k;
      for (__k = 0; __n != 0; __n >>= 1)
 ++__k;
      return __k - 1;
    }

  inline int
  __lg(int __n)
  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }

  inline long
  __lg(long __n)
  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }

  inline long long
  __lg(long long __n)
  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }

}

namespace std __attribute__ ((__visibility__ ("default"))) {
# 1028 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    inline bool
    equal(_II1 __first1, _II1 __last1, _II2 __first2)
    {

     
     
     


      ;

      return std::__equal_aux(std::__niter_base(__first1),
         std::__niter_base(__last1),
         std::__niter_base(__first2));
    }
# 1060 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    inline bool
    equal(_IIter1 __first1, _IIter1 __last1,
   _IIter2 __first2, _BinaryPredicate __binary_pred)
    {

     
     
      ;

      for (; __first1 != __last1; ++__first1, ++__first2)
 if (!bool(__binary_pred(*__first1, *__first2)))
   return false;
      return true;
    }
# 1091 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2)
    {

      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
     
     
     
     
      ;
      ;

      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
      std::__niter_base(__last1),
      std::__niter_base(__first2),
      std::__niter_base(__last2));
    }
# 1125 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2, typename _Compare>
    bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2, _Compare __comp)
    {
      typedef typename iterator_traits<_II1>::iterator_category _Category1;
      typedef typename iterator_traits<_II2>::iterator_category _Category2;
      typedef std::__lc_rai<_Category1, _Category2> __rai_type;


     
     
      ;
      ;

      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
    ++__first1, ++__first2)
 {
   if (__comp(*__first1, *__first2))
     return true;
   if (__comp(*__first2, *__first1))
     return false;
 }
      return __first1 == __last1 && __first2 != __last2;
    }
# 1165 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2)
    {

     
     
     


      ;

      while (__first1 != __last1 && *__first1 == *__first2)
        {
   ++__first1;
   ++__first2;
        }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }
# 1202 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {

     
     
      ;

      while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
        {
   ++__first1;
   ++__first2;
        }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }

}
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 1 3
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
       
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 2 3


# 1 "/usr/include/wchar.h" 1 3 4
# 37 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/stdio.h" 1 3 4
# 45 "/usr/include/stdio.h" 3 4
struct _IO_FILE;



typedef struct _IO_FILE FILE;





# 65 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 38 "/usr/include/wchar.h" 2 3 4




# 1 "/usr/include/bits/wchar.h" 1 3 4
# 43 "/usr/include/wchar.h" 2 3 4
# 52 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 352 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 53 "/usr/include/wchar.h" 2 3 4
# 83 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {

    unsigned int __wch;



    char __wchb[4];
  } __value;
} __mbstate_t;
# 104 "/usr/include/wchar.h" 3 4


typedef __mbstate_t mbstate_t;



# 129 "/usr/include/wchar.h" 3 4
extern "C" {




struct tm;









extern wchar_t *wcscpy (wchar_t *__restrict __dest,
   __const wchar_t *__restrict __src) throw ();

extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
    __const wchar_t *__restrict __src, size_t __n)
     throw ();


extern wchar_t *wcscat (wchar_t *__restrict __dest,
   __const wchar_t *__restrict __src) throw ();

extern wchar_t *wcsncat (wchar_t *__restrict __dest,
    __const wchar_t *__restrict __src, size_t __n)
     throw ();


extern int wcscmp (__const wchar_t *__s1, __const wchar_t *__s2)
     throw () __attribute__ ((__pure__));

extern int wcsncmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n)
     throw () __attribute__ ((__pure__));




extern int wcscasecmp (__const wchar_t *__s1, __const wchar_t *__s2) throw ();


extern int wcsncasecmp (__const wchar_t *__s1, __const wchar_t *__s2,
   size_t __n) throw ();





extern int wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
    __locale_t __loc) throw ();

extern int wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
     size_t __n, __locale_t __loc) throw ();





extern int wcscoll (__const wchar_t *__s1, __const wchar_t *__s2) throw ();



extern size_t wcsxfrm (wchar_t *__restrict __s1,
         __const wchar_t *__restrict __s2, size_t __n) throw ();








extern int wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2,
        __locale_t __loc) throw ();




extern size_t wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2,
    size_t __n, __locale_t __loc) throw ();


extern wchar_t *wcsdup (__const wchar_t *__s) throw () __attribute__ ((__malloc__));





extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcschr") __attribute__ ((__pure__));






extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcsrchr") __attribute__ ((__pure__));









extern wchar_t *wcschrnul (__const wchar_t *__s, wchar_t __wc)
     throw () __attribute__ ((__pure__));





extern size_t wcscspn (__const wchar_t *__wcs, __const wchar_t *__reject)
     throw () __attribute__ ((__pure__));


extern size_t wcsspn (__const wchar_t *__wcs, __const wchar_t *__accept)
     throw () __attribute__ ((__pure__));


extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, __const wchar_t *__accept)
     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wcspbrk (__const wchar_t *__wcs,
           __const wchar_t *__accept)
     throw () __asm ("wcspbrk") __attribute__ ((__pure__));






extern "C++" wchar_t *wcsstr (wchar_t *__haystack, __const wchar_t *__needle)
     throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wcsstr (__const wchar_t *__haystack,
          __const wchar_t *__needle)
     throw () __asm ("wcsstr") __attribute__ ((__pure__));






extern wchar_t *wcstok (wchar_t *__restrict __s,
   __const wchar_t *__restrict __delim,
   wchar_t **__restrict __ptr) throw ();


extern size_t wcslen (__const wchar_t *__s) throw () __attribute__ ((__pure__));





extern "C++" wchar_t *wcswcs (wchar_t *__haystack, __const wchar_t *__needle)
     throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wcswcs (__const wchar_t *__haystack,
          __const wchar_t *__needle)
     throw () __asm ("wcswcs") __attribute__ ((__pure__));
# 303 "/usr/include/wchar.h" 3 4
extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen)
     throw () __attribute__ ((__pure__));






extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
     throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c,
           size_t __n)
     throw () __asm ("wmemchr") __attribute__ ((__pure__));






extern int wmemcmp (__const wchar_t *__restrict __s1,
      __const wchar_t *__restrict __s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
    __const wchar_t *__restrict __s2, size_t __n) throw ();



extern wchar_t *wmemmove (wchar_t *__s1, __const wchar_t *__s2, size_t __n)
     throw ();


extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();





extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
     __const wchar_t *__restrict __s2, size_t __n)
     throw ();






extern wint_t btowc (int __c) throw ();



extern int wctob (wint_t __c) throw ();



extern int mbsinit (__const mbstate_t *__ps) throw () __attribute__ ((__pure__));



extern size_t mbrtowc (wchar_t *__restrict __pwc,
         __const char *__restrict __s, size_t __n,
         mbstate_t *__p) throw ();


extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
         mbstate_t *__restrict __ps) throw ();


extern size_t __mbrlen (__const char *__restrict __s, size_t __n,
   mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (__const char *__restrict __s, size_t __n,
        mbstate_t *__restrict __ps) throw ();








extern wint_t __btowc_alias (int __c) __asm ("btowc");
extern __inline __attribute__ ((__gnu_inline__)) wint_t
btowc (int __c) throw ()
{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
   ? (wint_t) __c : __btowc_alias (__c)); }

extern int __wctob_alias (wint_t __c) __asm ("wctob");
extern __inline __attribute__ ((__gnu_inline__)) int
wctob (wint_t __wc) throw ()
{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
   ? (int) __wc : __wctob_alias (__wc)); }

extern __inline __attribute__ ((__gnu_inline__)) size_t
mbrlen (__const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()

{ return (__ps != __null
   ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }





extern size_t mbsrtowcs (wchar_t *__restrict __dst,
    __const char **__restrict __src, size_t __len,
    mbstate_t *__restrict __ps) throw ();



extern size_t wcsrtombs (char *__restrict __dst,
    __const wchar_t **__restrict __src, size_t __len,
    mbstate_t *__restrict __ps) throw ();






extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
     __const char **__restrict __src, size_t __nmc,
     size_t __len, mbstate_t *__restrict __ps) throw ();



extern size_t wcsnrtombs (char *__restrict __dst,
     __const wchar_t **__restrict __src,
     size_t __nwc, size_t __len,
     mbstate_t *__restrict __ps) throw ();






extern int wcwidth (wchar_t __c) throw ();



extern int wcswidth (__const wchar_t *__s, size_t __n) throw ();






extern double wcstod (__const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr) throw ();





extern float wcstof (__const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) throw ();
extern long double wcstold (__const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) throw ();







extern long int wcstol (__const wchar_t *__restrict __nptr,
   wchar_t **__restrict __endptr, int __base) throw ();



extern unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
      wchar_t **__restrict __endptr, int __base)
     throw ();






__extension__
extern long long int wcstoll (__const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr, int __base)
     throw ();



__extension__
extern unsigned long long int wcstoull (__const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr,
     int __base) throw ();






__extension__
extern long long int wcstoq (__const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr, int __base)
     throw ();



__extension__
extern unsigned long long int wcstouq (__const wchar_t *__restrict __nptr,
           wchar_t **__restrict __endptr,
           int __base) throw ();
# 528 "/usr/include/wchar.h" 3 4
extern long int wcstol_l (__const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr, int __base,
     __locale_t __loc) throw ();

extern unsigned long int wcstoul_l (__const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr,
        int __base, __locale_t __loc) throw ();

__extension__
extern long long int wcstoll_l (__const wchar_t *__restrict __nptr,
    wchar_t **__restrict __endptr,
    int __base, __locale_t __loc) throw ();

__extension__
extern unsigned long long int wcstoull_l (__const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr,
       int __base, __locale_t __loc)
     throw ();

extern double wcstod_l (__const wchar_t *__restrict __nptr,
   wchar_t **__restrict __endptr, __locale_t __loc)
     throw ();

extern float wcstof_l (__const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr, __locale_t __loc)
     throw ();

extern long double wcstold_l (__const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         __locale_t __loc) throw ();






extern wchar_t *wcpcpy (wchar_t *__dest, __const wchar_t *__src) throw ();



extern wchar_t *wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n)
     throw ();
# 578 "/usr/include/wchar.h" 3 4
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();






extern int fwide (__FILE *__fp, int __mode) throw ();






extern int fwprintf (__FILE *__restrict __stream,
       __const wchar_t *__restrict __format, ...)
                                                           ;




extern int wprintf (__const wchar_t *__restrict __format, ...)
                                                           ;

extern int swprintf (wchar_t *__restrict __s, size_t __n,
       __const wchar_t *__restrict __format, ...)
     throw () ;





extern int vfwprintf (__FILE *__restrict __s,
        __const wchar_t *__restrict __format,
        __gnuc_va_list __arg)
                                                           ;




extern int vwprintf (__const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
                                                           ;


extern int vswprintf (wchar_t *__restrict __s, size_t __n,
        __const wchar_t *__restrict __format,
        __gnuc_va_list __arg)
     throw () ;






extern int fwscanf (__FILE *__restrict __stream,
      __const wchar_t *__restrict __format, ...)
                                                          ;




extern int wscanf (__const wchar_t *__restrict __format, ...)
                                                          ;

extern int swscanf (__const wchar_t *__restrict __s,
      __const wchar_t *__restrict __format, ...)
     throw () ;
# 678 "/usr/include/wchar.h" 3 4









extern int vfwscanf (__FILE *__restrict __s,
       __const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
                                                          ;




extern int vwscanf (__const wchar_t *__restrict __format,
      __gnuc_va_list __arg)
                                                          ;

extern int vswscanf (__const wchar_t *__restrict __s,
       __const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
     throw () ;
# 734 "/usr/include/wchar.h" 3 4









extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);





extern wint_t getwchar (void);






extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);





extern wint_t putwchar (wchar_t __wc);







extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
   __FILE *__restrict __stream);





extern int fputws (__const wchar_t *__restrict __ws,
     __FILE *__restrict __stream);






extern wint_t ungetwc (wint_t __wc, __FILE *__stream);

# 799 "/usr/include/wchar.h" 3 4
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);







extern wint_t fgetwc_unlocked (__FILE *__stream);







extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
# 825 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 835 "/usr/include/wchar.h" 3 4
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
     __FILE *__restrict __stream);







extern int fputws_unlocked (__const wchar_t *__restrict __ws,
       __FILE *__restrict __stream);







extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
   __const wchar_t *__restrict __format,
   __const struct tm *__restrict __tp) throw ();







extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
     __const wchar_t *__restrict __format,
     __const struct tm *__restrict __tp,
     __locale_t __loc) throw ();
# 882 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/bits/wchar2.h" 1 3 4
# 25 "/usr/include/bits/wchar2.h" 3 4
extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
          __const wchar_t *__restrict __s2, size_t __n,
          size_t __ns1) throw ();
extern wchar_t *__wmemcpy_alias (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmemcpy")


            ;
extern wchar_t *__wmemcpy_chk_warn (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemcpy_chk")



     __attribute__((__warning__ ("wmemcpy called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
wmemcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ()

{
  if (__builtin_object_size (__s1, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wmemcpy_chk (__s1, __s2, __n,
         __builtin_object_size (__s1, 0) / sizeof (wchar_t));

      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
 return __wmemcpy_chk_warn (__s1, __s2, __n,
       __builtin_object_size (__s1, 0) / sizeof (wchar_t));
    }
  return __wmemcpy_alias (__s1, __s2, __n);
}


extern wchar_t *__wmemmove_chk (wchar_t *__s1, __const wchar_t *__s2,
    size_t __n, size_t __ns1) throw ();
extern wchar_t *__wmemmove_alias (wchar_t *__s1, __const wchar_t *__s2, size_t __n) throw () __asm__ ("" "wmemmove")

                               ;
extern wchar_t *__wmemmove_chk_warn (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemmove_chk")



     __attribute__((__warning__ ("wmemmove called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
wmemmove (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ()

{
  if (__builtin_object_size (__s1, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wmemmove_chk (__s1, __s2, __n,
          __builtin_object_size (__s1, 0) / sizeof (wchar_t));

      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
 return __wmemmove_chk_warn (__s1, __s2, __n,
        __builtin_object_size (__s1, 0) / sizeof (wchar_t));
    }
  return __wmemmove_alias (__s1, __s2, __n);
}



extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
    __const wchar_t *__restrict __s2, size_t __n,
    size_t __ns1) throw ();
extern wchar_t *__wmempcpy_alias (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmempcpy")


                           ;
extern wchar_t *__wmempcpy_chk_warn (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmempcpy_chk")



     __attribute__((__warning__ ("wmempcpy called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
wmempcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ()

{
  if (__builtin_object_size (__s1, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wmempcpy_chk (__s1, __s2, __n,
          __builtin_object_size (__s1, 0) / sizeof (wchar_t));

      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
 return __wmempcpy_chk_warn (__s1, __s2, __n,
        __builtin_object_size (__s1, 0) / sizeof (wchar_t));
    }
  return __wmempcpy_alias (__s1, __s2, __n);
}



extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
          size_t __ns) throw ();
extern wchar_t *__wmemset_alias (wchar_t *__s, wchar_t __c, size_t __n) throw () __asm__ ("" "wmemset")
                             ;
extern wchar_t *__wmemset_chk_warn (wchar_t *__s, wchar_t __c, size_t __n, size_t __ns) throw () __asm__ ("" "__wmemset_chk")


     __attribute__((__warning__ ("wmemset called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
wmemset (wchar_t *__restrict __s, wchar_t __c, size_t __n) throw ()
{
  if (__builtin_object_size (__s, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wmemset_chk (__s, __c, __n, __builtin_object_size (__s, 0) / sizeof (wchar_t));

      if (__n > __builtin_object_size (__s, 0) / sizeof (wchar_t))
 return __wmemset_chk_warn (__s, __c, __n,
       __builtin_object_size (__s, 0) / sizeof (wchar_t));
    }
  return __wmemset_alias (__s, __c, __n);
}


extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
         __const wchar_t *__restrict __src,
         size_t __n) throw ();
extern wchar_t *__wcscpy_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw () __asm__ ("" "wcscpy")

                                                ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
wcscpy (wchar_t *__dest, __const wchar_t *__src) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    return __wcscpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
  return __wcscpy_alias (__dest, __src);
}


extern wchar_t *__wcpcpy_chk (wchar_t *__dest, __const wchar_t *__src,
         size_t __destlen) throw ();
extern wchar_t *__wcpcpy_alias (wchar_t *__dest, __const wchar_t *__src) throw () __asm__ ("" "wcpcpy")

           ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
wcpcpy (wchar_t *__dest, __const wchar_t *__src) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    return __wcpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
  return __wcpcpy_alias (__dest, __src);
}


extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
          __const wchar_t *__restrict __src, size_t __n,
          size_t __destlen) throw ();
extern wchar_t *__wcsncpy_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncpy")


                          ;
extern wchar_t *__wcsncpy_chk_warn (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcsncpy_chk")



     __attribute__((__warning__ ("wcsncpy called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
wcsncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wcsncpy_chk (__dest, __src, __n,
         __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
      if (__n > __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t))
 return __wcsncpy_chk_warn (__dest, __src, __n,
       __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
    }
  return __wcsncpy_alias (__dest, __src, __n);
}


extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
          __const wchar_t *__restrict __src, size_t __n,
          size_t __destlen) throw ();
extern wchar_t *__wcpncpy_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcpncpy")


                          ;
extern wchar_t *__wcpncpy_chk_warn (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcpncpy_chk")



     __attribute__((__warning__ ("wcpncpy called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wcpncpy_chk (__dest, __src, __n,
         __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
      if (__n > __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t))
 return __wcpncpy_chk_warn (__dest, __src, __n,
       __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
    }
  return __wcpncpy_alias (__dest, __src, __n);
}


extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
         __const wchar_t *__restrict __src,
         size_t __destlen) throw ();
extern wchar_t *__wcscat_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw () __asm__ ("" "wcscat")

                                                ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
wcscat (wchar_t *__dest, __const wchar_t *__src) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    return __wcscat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
  return __wcscat_alias (__dest, __src);
}


extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
          __const wchar_t *__restrict __src,
          size_t __n, size_t __destlen) throw ();
extern wchar_t *__wcsncat_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncat")


                          ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
wcsncat (wchar_t *__dest, __const wchar_t *__src, size_t __n) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    return __wcsncat_chk (__dest, __src, __n,
     __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
  return __wcsncat_alias (__dest, __src, __n);
}


extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
      int __flag, size_t __s_len,
      __const wchar_t *__restrict __format, ...)
     throw () ;

extern int __swprintf_alias (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, ...) throw () __asm__ ("" "swprintf")


             ;


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
swprintf (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, ...) throw ()

{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 || 2 > 1)
    return __swprintf_chk (__s, __n, 2 - 1,
      __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
      __fmt, __builtin_va_arg_pack ());
  return __swprintf_alias (__s, __n, __fmt, __builtin_va_arg_pack ());
}
# 302 "/usr/include/bits/wchar2.h" 3 4
extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
       int __flag, size_t __s_len,
       __const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
     throw () ;

extern int __vswprintf_alias (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw () __asm__ ("" "vswprintf")


                                     ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
vswprintf (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw ()

{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 || 2 > 1)
    return __vswprintf_chk (__s, __n, 2 - 1,
       __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t), __fmt, __ap);
  return __vswprintf_alias (__s, __n, __fmt, __ap);
}




extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
      __const wchar_t *__restrict __format, ...);
extern int __wprintf_chk (int __flag, __const wchar_t *__restrict __format,
     ...);
extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
       __const wchar_t *__restrict __format,
       __gnuc_va_list __ap);
extern int __vwprintf_chk (int __flag, __const wchar_t *__restrict __format,
      __gnuc_va_list __ap);


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
wprintf (__const wchar_t *__restrict __fmt, ...)
{
  return __wprintf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
fwprintf (__FILE *__restrict __stream, __const wchar_t *__restrict __fmt, ...)
{
  return __fwprintf_chk (__stream, 2 - 1, __fmt,
    __builtin_va_arg_pack ());
}







extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
vwprintf (__const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vwprintf_chk (2 - 1, __fmt, __ap);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
vfwprintf (__FILE *__restrict __stream,
    __const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vfwprintf_chk (__stream, 2 - 1, __fmt, __ap);
}



extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
         __FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws")

                                              __attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws called with bigger size than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n) || __n <= 0)
 return __fgetws_chk (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
        __n, __stream);

      if ((size_t) __n > __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t))
 return __fgetws_chk_warn (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
      __n, __stream);
    }
  return __fgetws_alias (__s, __n, __stream);
}


extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
           int __n, __FILE *__restrict __stream)
  __attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_unlocked_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws_unlocked")


  __attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_unlocked_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_unlocked_chk")



     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws_unlocked called with bigger size than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n) || __n <= 0)
 return __fgetws_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
          __n, __stream);

      if ((size_t) __n > __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t))
 return __fgetws_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
        __n, __stream);
    }
  return __fgetws_unlocked_alias (__s, __n, __stream);
}



extern size_t __wcrtomb_chk (char *__s, wchar_t __wchar, mbstate_t *__p,
     size_t __buflen) throw () __attribute__ ((__warn_unused_result__));
extern size_t __wcrtomb_alias (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcrtomb")

                                                __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) size_t
wcrtomb (char *__s, wchar_t __wchar, mbstate_t *__ps) throw ()
{







  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
    return __wcrtomb_chk (__s, __wchar, __ps, __builtin_object_size (__s, 2 > 1));
  return __wcrtomb_alias (__s, __wchar, __ps);
}


extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
          __const char **__restrict __src,
          size_t __len, mbstate_t *__restrict __ps,
          size_t __dstlen) throw ();
extern size_t __mbsrtowcs_alias (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsrtowcs")



                   ;
extern size_t __mbsrtowcs_chk_warn (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsrtowcs_chk")




     __attribute__((__warning__ ("mbsrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
mbsrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __mbsrtowcs_chk (__dst, __src, __len, __ps,
    __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));

      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
 return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps,
         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
    }
  return __mbsrtowcs_alias (__dst, __src, __len, __ps);
}


extern size_t __wcsrtombs_chk (char *__restrict __dst,
          __const wchar_t **__restrict __src,
          size_t __len, mbstate_t *__restrict __ps,
          size_t __dstlen) throw ();
extern size_t __wcsrtombs_alias (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsrtombs")



                   ;
extern size_t __wcsrtombs_chk_warn (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsrtombs_chk")




    __attribute__((__warning__ ("wcsrtombs called with dst buffer smaller than len")));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
wcsrtombs (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __wcsrtombs_chk (__dst, __src, __len, __ps, __builtin_object_size (__dst, 2 > 1));

      if (__len > __builtin_object_size (__dst, 2 > 1))
 return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __builtin_object_size (__dst, 2 > 1));
    }
  return __wcsrtombs_alias (__dst, __src, __len, __ps);
}



extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
    __const char **__restrict __src, size_t __nmc,
    size_t __len, mbstate_t *__restrict __ps,
    size_t __dstlen) throw ();
extern size_t __mbsnrtowcs_alias (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsnrtowcs")



                    ;
extern size_t __mbsnrtowcs_chk_warn (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsnrtowcs_chk")




     __attribute__((__warning__ ("mbsnrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
mbsnrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
     __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));

      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
 return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps,
          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
    }
  return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);
}


extern size_t __wcsnrtombs_chk (char *__restrict __dst,
    __const wchar_t **__restrict __src,
    size_t __nwc, size_t __len,
    mbstate_t *__restrict __ps, size_t __dstlen)
     throw ();
extern size_t __wcsnrtombs_alias (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsnrtombs")



                                                  ;
extern size_t __wcsnrtombs_chk_warn (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsnrtombs_chk")





     __attribute__((__warning__ ("wcsnrtombs called with dst buffer smaller than len")));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
wcsnrtombs (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps,
     __builtin_object_size (__dst, 2 > 1));

      if (__len > __builtin_object_size (__dst, 2 > 1))
 return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps,
          __builtin_object_size (__dst, 2 > 1));
    }
  return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);
}
# 883 "/usr/include/wchar.h" 2 3 4






}
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 2 3
# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  using ::mbstate_t;

}
# 139 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  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 ::mbsinit;
  using ::mbsrtowcs;
  using ::putwc;
  using ::putwchar;

  using ::swprintf;

  using ::swscanf;
  using ::ungetwc;
  using ::vfwprintf;

  using ::vfwscanf;


  using ::vswprintf;


  using ::vswscanf;

  using ::vwprintf;

  using ::vwscanf;

  using ::wcrtomb;
  using ::wcscat;
  using ::wcscmp;
  using ::wcscoll;
  using ::wcscpy;
  using ::wcscspn;
  using ::wcsftime;
  using ::wcslen;
  using ::wcsncat;
  using ::wcsncmp;
  using ::wcsncpy;
  using ::wcsrtombs;
  using ::wcsspn;
  using ::wcstod;

  using ::wcstof;

  using ::wcstok;
  using ::wcstol;
  using ::wcstoul;
  using ::wcsxfrm;
  using ::wctob;
  using ::wmemcmp;
  using ::wmemcpy;
  using ::wmemmove;
  using ::wmemset;
  using ::wprintf;
  using ::wscanf;
  using ::wcschr;
  using ::wcspbrk;
  using ::wcsrchr;
  using ::wcsstr;
  using ::wmemchr;
# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
}







namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {






  using ::wcstold;
# 258 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
  using ::wcstoll;
  using ::wcstoull;


}

namespace std __attribute__ ((__visibility__ ("default"))) {

  using ::__gnu_cxx::wcstold;
  using ::__gnu_cxx::wcstoll;
  using ::__gnu_cxx::wcstoull;

}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 2 3
# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 88 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
  typedef long streamoff;
# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
  typedef ptrdiff_t streamsize;
# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
  template<typename _StateT>
    class fpos
    {
    private:
      streamoff _M_off;
      _StateT _M_state;

    public:




      fpos()
      : _M_off(0), _M_state() { }
# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
      fpos(streamoff __off)
      : _M_off(__off), _M_state() { }


      operator streamoff() const { return _M_off; }


      void
      state(_StateT __st)
      { _M_state = __st; }


      _StateT
      state() const
      { return _M_state; }





      fpos&
      operator+=(streamoff __off)
      {
 _M_off += __off;
 return *this;
      }





      fpos&
      operator-=(streamoff __off)
      {
 _M_off -= __off;
 return *this;
      }







      fpos
      operator+(streamoff __off) const
      {
 fpos __pos(*this);
 __pos += __off;
 return __pos;
      }







      fpos
      operator-(streamoff __off) const
      {
 fpos __pos(*this);
 __pos -= __off;
 return __pos;
      }






      streamoff
      operator-(const fpos& __other) const
      { return _M_off - __other._M_off; }
    };






  template<typename _StateT>
    inline bool
    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) == streamoff(__rhs); }

  template<typename _StateT>
    inline bool
    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) != streamoff(__rhs); }





  typedef fpos<mbstate_t> streampos;

  typedef fpos<mbstate_t> wstreampos;
# 239 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 2 3


# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 2 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 2 3
# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
  template<typename _CharT>
    struct _Char_types
    {
      typedef unsigned long int_type;
      typedef std::streampos pos_type;
      typedef std::streamoff off_type;
      typedef std::mbstate_t state_type;
    };
# 89 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
  template<typename _CharT>
    struct char_traits
    {
      typedef _CharT char_type;
      typedef typename _Char_types<_CharT>::int_type int_type;
      typedef typename _Char_types<_CharT>::pos_type pos_type;
      typedef typename _Char_types<_CharT>::off_type off_type;
      typedef typename _Char_types<_CharT>::state_type state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);

      static std::size_t
      length(const char_type* __s);

      static const char_type*
      find(const char_type* __s, std::size_t __n, const char_type& __a);

      static char_type*
      move(char_type* __s1, const char_type* __s2, std::size_t __n);

      static char_type*
      copy(char_type* __s1, const char_type* __s2, std::size_t __n);

      static char_type*
      assign(char_type* __s, std::size_t __n, char_type __a);

      static char_type
      to_char_type(const int_type& __c)
      { return static_cast<char_type>(__c); }

      static int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(__c); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof()
      { return static_cast<int_type>((-1)); }

      static int_type
      not_eof(const int_type& __c)
      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
    };

  template<typename _CharT>
    int
    char_traits<_CharT>::
    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
 if (lt(__s1[__i], __s2[__i]))
   return -1;
 else if (lt(__s2[__i], __s1[__i]))
   return 1;
      return 0;
    }

  template<typename _CharT>
    std::size_t
    char_traits<_CharT>::
    length(const char_type* __p)
    {
      std::size_t __i = 0;
      while (!eq(__p[__i], char_type()))
        ++__i;
      return __i;
    }

  template<typename _CharT>
    const typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    find(const char_type* __s, std::size_t __n, const char_type& __a)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
        if (eq(__s[__i], __a))
          return __s + __i;
      return 0;
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    move(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
          __n * sizeof(char_type)));
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
    {

      std::copy(__s2, __s2 + __n, __s1);
      return __s1;
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    assign(char_type* __s, std::size_t __n, char_type __a)
    {

      std::fill_n(__s, __n, __a);
      return __s;
    }

}

namespace std __attribute__ ((__visibility__ ("default"))) {
# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
  template<class _CharT>
    struct char_traits : public __gnu_cxx::char_traits<_CharT>
    { };



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

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      { return __builtin_memcmp(__s1, __s2, __n); }

      static size_t
      length(const char_type* __s)
      { return __builtin_strlen(__s); }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      { return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      { return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      { return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }

      static char_type
      to_char_type(const int_type& __c)
      { return static_cast<char_type>(__c); }



      static int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof()
      { return static_cast<int_type>((-1)); }

      static int_type
      not_eof(const int_type& __c)
      { return (__c == eof()) ? 0 : __c; }
  };




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

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      { return wmemcmp(__s1, __s2, __n); }

      static size_t
      length(const char_type* __s)
      { return wcslen(__s); }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      { return wmemchr(__s, __a, __n); }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      { return wmemmove(__s1, __s2, __n); }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      { return wmemcpy(__s1, __s2, __n); }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      { return wmemset(__s, __a, __n); }

      static char_type
      to_char_type(const int_type& __c)
      { return char_type(__c); }

      static int_type
      to_int_type(const char_type& __c)
      { return int_type(__c); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof()
      { return static_cast<int_type>((0xffffffffu)); }

      static int_type
      not_eof(const int_type& __c)
      { return eq_int_type(__c, eof()) ? 0 : __c; }
  };


}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 1 3
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/new_allocator.h" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/new_allocator.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 3
       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 3
       
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 3

#pragma GCC visibility push(default)



extern "C++" {

namespace std
{
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 3
  class exception
  {
  public:
    exception() throw() { }
    virtual ~exception() throw();



    virtual const char* what() const throw();
  };



  class bad_exception : public exception
  {
  public:
    bad_exception() throw() { }



    virtual ~bad_exception() throw();


    virtual const char* what() const throw();
  };


  typedef void (*terminate_handler) ();


  typedef void (*unexpected_handler) ();


  terminate_handler set_terminate(terminate_handler) throw();



  void terminate() throw() __attribute__ ((__noreturn__));


  unexpected_handler set_unexpected(unexpected_handler) throw();



  void unexpected() __attribute__ ((__noreturn__));
# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 3
  bool uncaught_exception() throw() __attribute__ ((__pure__));


}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
# 141 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 3
  void __verbose_terminate_handler();

}

}

#pragma GCC visibility pop
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 2 3

#pragma GCC visibility push(default)

extern "C++" {

namespace std
{






  class bad_alloc : public exception
  {
  public:
    bad_alloc() throw() { }



    virtual ~bad_alloc() throw();


    virtual const char* what() const throw();
  };

  struct nothrow_t { };

  extern const nothrow_t nothrow;



  typedef void (*new_handler)();



  new_handler set_new_handler(new_handler) throw();
}
# 93 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 3
void* operator new(std::size_t) throw (std::bad_alloc);
void* operator new[](std::size_t) throw (std::bad_alloc);
void operator delete(void*) throw();
void operator delete[](void*) throw();
void* operator new(std::size_t, const std::nothrow_t&) throw();
void* operator new[](std::size_t, const std::nothrow_t&) throw();
void operator delete(void*, const std::nothrow_t&) throw();
void operator delete[](void*, const std::nothrow_t&) throw();


inline void* operator new(std::size_t, void* __p) throw() { return __p; }
inline void* operator new[](std::size_t, void* __p) throw() { return __p; }


inline void operator delete (void*, void*) throw() { }
inline void operator delete[](void*, void*) throw() { }

}

#pragma GCC visibility pop
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/new_allocator.h" 2 3



namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {

  using std::size_t;
  using std::ptrdiff_t;
# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/new_allocator.h" 3
  template<typename _Tp>
    class new_allocator
    {
    public:
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Tp* pointer;
      typedef const _Tp* const_pointer;
      typedef _Tp& reference;
      typedef const _Tp& const_reference;
      typedef _Tp value_type;

      template<typename _Tp1>
        struct rebind
        { typedef new_allocator<_Tp1> other; };

      new_allocator() throw() { }

      new_allocator(const new_allocator&) throw() { }

      template<typename _Tp1>
        new_allocator(const new_allocator<_Tp1>&) throw() { }

      ~new_allocator() throw() { }

      pointer
      address(reference __x) const { return &__x; }

      const_pointer
      address(const_reference __x) const { return &__x; }



      pointer
      allocate(size_type __n, const void* = 0)
      {
 if (__n > this->max_size())
   std::__throw_bad_alloc();

 return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
      }


      void
      deallocate(pointer __p, size_type)
      { ::operator delete(__p); }

      size_type
      max_size() const throw()
      { return size_t(-1) / sizeof(_Tp); }



      void
      construct(pointer __p, const _Tp& __val)
      { ::new((void *)__p) _Tp(__val); }
# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/new_allocator.h" 3
      void
      destroy(pointer __p) { __p->~_Tp(); }
    };

  template<typename _Tp>
    inline bool
    operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
    { return true; }

  template<typename _Tp>
    inline bool
    operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
    { return false; }

}
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3
# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 3
  template<typename _Tp>
    class allocator;


  template<>
    class allocator<void>
    {
    public:
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef void* pointer;
      typedef const void* const_pointer;
      typedef void value_type;

      template<typename _Tp1>
        struct rebind
        { typedef allocator<_Tp1> other; };
    };
# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 3
  template<typename _Tp>
    class allocator: public __gnu_cxx::new_allocator<_Tp>
    {
   public:
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Tp* pointer;
      typedef const _Tp* const_pointer;
      typedef _Tp& reference;
      typedef const _Tp& const_reference;
      typedef _Tp value_type;

      template<typename _Tp1>
        struct rebind
        { typedef allocator<_Tp1> other; };

      allocator() throw() { }

      allocator(const allocator& __a) throw()
      : __gnu_cxx::new_allocator<_Tp>(__a) { }

      template<typename _Tp1>
        allocator(const allocator<_Tp1>&) throw() { }

      ~allocator() throw() { }


    };

  template<typename _T1, typename _T2>
    inline bool
    operator==(const allocator<_T1>&, const allocator<_T2>&)
    { return true; }

  template<typename _Tp>
    inline bool
    operator==(const allocator<_Tp>&, const allocator<_Tp>&)
    { return true; }

  template<typename _T1, typename _T2>
    inline bool
    operator!=(const allocator<_T1>&, const allocator<_T2>&)
    { return false; }

  template<typename _Tp>
    inline bool
    operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
    { return false; }





  extern template class allocator<char>;
  extern template class allocator<wchar_t>;






  template<typename _Alloc, bool = __is_empty(_Alloc)>
    struct __alloc_swap
    { static void _S_do_it(_Alloc&, _Alloc&) { } };

  template<typename _Alloc>
    struct __alloc_swap<_Alloc, false>
    {
      static void
      _S_do_it(_Alloc& __one, _Alloc& __two)
      {

 if (__one != __two)
   swap(__one, __two);
      }
    };


  template<typename _Alloc, bool = __is_empty(_Alloc)>
    struct __alloc_neq
    {
      static bool
      _S_do_it(const _Alloc&, const _Alloc&)
      { return false; }
    };

  template<typename _Alloc>
    struct __alloc_neq<_Alloc, false>
    {
      static bool
      _S_do_it(const _Alloc& __one, const _Alloc& __two)
      { return __one != __two; }
    };
# 204 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 3
}
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 3
       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 1 3
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 3
       
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/clocale" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/clocale" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/clocale" 3


# 1 "/usr/include/locale.h" 1 3 4
# 29 "/usr/include/locale.h" 3 4
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 30 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/bits/locale.h" 1 3 4
# 27 "/usr/include/bits/locale.h" 3 4
enum
{
  __LC_CTYPE = 0,
  __LC_NUMERIC = 1,
  __LC_TIME = 2,
  __LC_COLLATE = 3,
  __LC_MONETARY = 4,
  __LC_MESSAGES = 5,
  __LC_ALL = 6,
  __LC_PAPER = 7,
  __LC_NAME = 8,
  __LC_ADDRESS = 9,
  __LC_TELEPHONE = 10,
  __LC_MEASUREMENT = 11,
  __LC_IDENTIFICATION = 12
};
# 31 "/usr/include/locale.h" 2 3 4

extern "C" {
# 51 "/usr/include/locale.h" 3 4



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_p_sep_by_space;

  char int_n_cs_precedes;

  char int_n_sep_by_space;






  char int_p_sign_posn;
  char int_n_sign_posn;
# 121 "/usr/include/locale.h" 3 4
};



extern char *setlocale (int __category, __const char *__locale) throw ();


extern struct lconv *localeconv (void) throw ();


# 152 "/usr/include/locale.h" 3 4
extern __locale_t newlocale (int __category_mask, __const char *__locale,
        __locale_t __base) throw ();
# 187 "/usr/include/locale.h" 3 4
extern __locale_t duplocale (__locale_t __dataset) throw ();



extern void freelocale (__locale_t __dataset) throw ();






extern __locale_t uselocale (__locale_t __dataset) throw ();







}
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/clocale" 2 3
# 53 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/clocale" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  using ::lconv;
  using ::setlocale;
  using ::localeconv;

}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3






namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {

  extern "C" __typeof(uselocale) __uselocale;

}


namespace std __attribute__ ((__visibility__ ("default"))) {

  typedef __locale_t __c_locale;





  inline int
  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
     char* __out,
     const int __size __attribute__ ((__unused__)),
     const char* __fmt, ...)
  {

    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 3
    __builtin_va_list __args;
    __builtin_va_start(__args, __fmt);


    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);




    __builtin_va_end(__args);


    __gnu_cxx::__uselocale(__old);







    return __ret;
  }

}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iosfwd" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iosfwd" 3
       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iosfwd" 3





namespace std __attribute__ ((__visibility__ ("default"))) {
# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iosfwd" 3
  class ios_base;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ios;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_streambuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_istream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ostream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_iostream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
     typename _Alloc = allocator<_CharT> >
    class basic_stringbuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_istringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_ostringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_stringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_filebuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ifstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ofstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_fstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class ostreambuf_iterator;




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


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



}
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 3


# 1 "/usr/include/ctype.h" 1 3 4
# 28 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 28 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/bits/types.h" 2 3 4


typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;







typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
# 131 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 132 "/usr/include/bits/types.h" 2 3 4


typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;

typedef int __daddr_t;
typedef long int __swblk_t;
typedef int __key_t;


typedef int __clockid_t;


typedef void * __timer_t;


typedef long int __blksize_t;




typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;


typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;


typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;

typedef long int __ssize_t;



typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;


typedef long int __intptr_t;


typedef unsigned int __socklen_t;
# 29 "/usr/include/ctype.h" 2 3 4

extern "C" {
# 41 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 37 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/endian.h" 1 3 4
# 38 "/usr/include/endian.h" 2 3 4
# 61 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 28 "/usr/include/bits/byteswap.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/bits/byteswap.h" 2 3 4
# 62 "/usr/include/endian.h" 2 3 4
# 42 "/usr/include/ctype.h" 2 3 4






enum
{
  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 81 "/usr/include/ctype.h" 3 4
extern __const unsigned short int **__ctype_b_loc (void)
     throw () __attribute__ ((__const));
extern __const __int32_t **__ctype_tolower_loc (void)
     throw () __attribute__ ((__const));
extern __const __int32_t **__ctype_toupper_loc (void)
     throw () __attribute__ ((__const));
# 96 "/usr/include/ctype.h" 3 4






extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();



extern int tolower (int __c) throw ();


extern int toupper (int __c) throw ();








extern int isblank (int) throw ();






extern int isctype (int __c, int __mask) throw ();






extern int isascii (int __c) throw ();



extern int toascii (int __c) throw ();



extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 247 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();

extern int isblank_l (int, __locale_t) throw ();



extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();


extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
# 323 "/usr/include/ctype.h" 3 4
}
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 2 3
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  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;

}
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 3
  class locale;

  template<typename _Facet>
    bool
    has_facet(const locale&) throw();

  template<typename _Facet>
    const _Facet&
    use_facet(const locale&);


  template<typename _CharT>
    bool
    isspace(_CharT, const locale&);

  template<typename _CharT>
    bool
    isprint(_CharT, const locale&);

  template<typename _CharT>
    bool
    iscntrl(_CharT, const locale&);

  template<typename _CharT>
    bool
    isupper(_CharT, const locale&);

  template<typename _CharT>
    bool
    islower(_CharT, const locale&);

  template<typename _CharT>
    bool
    isalpha(_CharT, const locale&);

  template<typename _CharT>
    bool
    isdigit(_CharT, const locale&);

  template<typename _CharT>
    bool
    ispunct(_CharT, const locale&);

  template<typename _CharT>
    bool
    isxdigit(_CharT, const locale&);

  template<typename _CharT>
    bool
    isalnum(_CharT, const locale&);

  template<typename _CharT>
    bool
    isgraph(_CharT, const locale&);

  template<typename _CharT>
    _CharT
    toupper(_CharT, const locale&);

  template<typename _CharT>
    _CharT
    tolower(_CharT, const locale&);


  class ctype_base;
  template<typename _CharT>
    class ctype;
  template<> class ctype<char>;

  template<> class ctype<wchar_t>;

  template<typename _CharT>
    class ctype_byname;


  class codecvt_base;
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt;
  template<> class codecvt<char, char, mbstate_t>;

  template<> class codecvt<wchar_t, char, mbstate_t>;

  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname;



  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class num_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class num_put;

  template<typename _CharT> class numpunct;
  template<typename _CharT> class numpunct_byname;


  template<typename _CharT>
    class collate;
  template<typename _CharT> class
    collate_byname;


  class time_base;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get_byname;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put_byname;


  class money_base;

  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class money_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class money_put;

  template<typename _CharT, bool _Intl = false>
    class moneypunct;
  template<typename _CharT, bool _Intl = false>
    class moneypunct_byname;


  class messages_base;
  template<typename _CharT>
    class messages;
  template<typename _CharT>
    class messages_byname;

}
# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream_insert.h" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream_insert.h" 3
       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream_insert.h" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cxxabi-forced.h" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cxxabi-forced.h" 3
       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cxxabi-forced.h" 3

#pragma GCC visibility push(default)


namespace __cxxabiv1
{







  class __forced_unwind
  {
    virtual ~__forced_unwind() throw();


    virtual void __pure_dummy() = 0;
  };
}


#pragma GCC visibility pop
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream_insert.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _CharT, typename _Traits>
    inline void
    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
      const _CharT* __s, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
      if (__put != __n)
 __out.setstate(__ios_base::badbit);
    }

  template<typename _CharT, typename _Traits>
    inline void
    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      const _CharT __c = __out.fill();
      for (; __n > 0; --__n)
 {
   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
   if (_Traits::eq_int_type(__put, _Traits::eof()))
     {
       __out.setstate(__ios_base::badbit);
       break;
     }
 }
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
       const _CharT* __s, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
 {
   try
     {
       const streamsize __w = __out.width();
       if (__w > __n)
  {
    const bool __left = ((__out.flags()
     & __ios_base::adjustfield)
           == __ios_base::left);
    if (!__left)
      __ostream_fill(__out, __w - __n);
    if (__out.good())
      __ostream_write(__out, __s, __n);
    if (__left && __out.good())
      __ostream_fill(__out, __w - __n);
  }
       else
  __ostream_write(__out, __s, __n);
       __out.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __out._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     { __out._M_setstate(__ios_base::badbit); }
 }
      return __out;
    }





  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);


  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
          streamsize);



}
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 1 3
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 99 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
  template<typename _Arg, typename _Result>
    struct unary_function
    {
      typedef _Arg argument_type;


      typedef _Result result_type;
    };




  template<typename _Arg1, typename _Arg2, typename _Result>
    struct binary_function
    {
      typedef _Arg1 first_argument_type;


      typedef _Arg2 second_argument_type;
      typedef _Result result_type;
    };
# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
  template<typename _Tp>
    struct plus : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x + __y; }
    };


  template<typename _Tp>
    struct minus : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x - __y; }
    };


  template<typename _Tp>
    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x * __y; }
    };


  template<typename _Tp>
    struct divides : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x / __y; }
    };


  template<typename _Tp>
    struct modulus : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x % __y; }
    };


  template<typename _Tp>
    struct negate : public unary_function<_Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x) const
      { return -__x; }
    };
# 198 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
  template<typename _Tp>
    struct equal_to : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x == __y; }
    };


  template<typename _Tp>
    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x != __y; }
    };


  template<typename _Tp>
    struct greater : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x > __y; }
    };


  template<typename _Tp>
    struct less : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x < __y; }
    };


  template<typename _Tp>
    struct greater_equal : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x >= __y; }
    };


  template<typename _Tp>
    struct less_equal : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x <= __y; }
    };
# 262 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
  template<typename _Tp>
    struct logical_and : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x && __y; }
    };


  template<typename _Tp>
    struct logical_or : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x || __y; }
    };


  template<typename _Tp>
    struct logical_not : public unary_function<_Tp, bool>
    {
      bool
      operator()(const _Tp& __x) const
      { return !__x; }
    };




  template<typename _Tp>
    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x & __y; }
    };

  template<typename _Tp>
    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x | __y; }
    };

  template<typename _Tp>
    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x ^ __y; }
    };
# 345 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
  template<typename _Predicate>
    class unary_negate
    : public unary_function<typename _Predicate::argument_type, bool>
    {
    public:
      _Predicate _M_pred;

    public:
      explicit
      unary_negate(const _Predicate& __x) : _M_pred(__x) { }

      bool
      operator()(const typename _Predicate::argument_type& __x) const
      { return !_M_pred(__x); }
    };


  template<typename _Predicate>
    inline unary_negate<_Predicate>
    not1(const _Predicate& __pred)
    { return unary_negate<_Predicate>(__pred); }


  template<typename _Predicate>
    class binary_negate
    : public binary_function<typename _Predicate::first_argument_type,
        typename _Predicate::second_argument_type, bool>
    {
    public:
      _Predicate _M_pred;

    public:
      explicit
      binary_negate(const _Predicate& __x) : _M_pred(__x) { }

      bool
      operator()(const typename _Predicate::first_argument_type& __x,
   const typename _Predicate::second_argument_type& __y) const
      { return !_M_pred(__x, __y); }
    };


  template<typename _Predicate>
    inline binary_negate<_Predicate>
    not2(const _Predicate& __pred)
    { return binary_negate<_Predicate>(__pred); }
# 416 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
  template<typename _Arg, typename _Result>
    class pointer_to_unary_function : public unary_function<_Arg, _Result>
    {
    public:
      _Result (*_M_ptr)(_Arg);

    public:
      pointer_to_unary_function() { }

      explicit
      pointer_to_unary_function(_Result (*__x)(_Arg))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg __x) const
      { return _M_ptr(__x); }
    };


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


  template<typename _Arg1, typename _Arg2, typename _Result>
    class pointer_to_binary_function
    : public binary_function<_Arg1, _Arg2, _Result>
    {
    public:
      _Result (*_M_ptr)(_Arg1, _Arg2);

    public:
      pointer_to_binary_function() { }

      explicit
      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg1 __x, _Arg2 __y) const
      { return _M_ptr(__x, __y); }
    };


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


  template<typename _Tp>
    struct _Identity : public unary_function<_Tp,_Tp>
    {
      _Tp&
      operator()(_Tp& __x) const
      { return __x; }

      const _Tp&
      operator()(const _Tp& __x) const
      { return __x; }
    };

  template<typename _Pair>
    struct _Select1st : public unary_function<_Pair,
           typename _Pair::first_type>
    {
      typename _Pair::first_type&
      operator()(_Pair& __x) const
      { return __x.first; }

      const typename _Pair::first_type&
      operator()(const _Pair& __x) const
      { return __x.first; }
    };

  template<typename _Pair>
    struct _Select2nd : public unary_function<_Pair,
           typename _Pair::second_type>
    {
      typename _Pair::second_type&
      operator()(_Pair& __x) const
      { return __x.second; }

      const typename _Pair::second_type&
      operator()(const _Pair& __x) const
      { return __x.second; }
    };
# 523 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
  template<typename _Ret, typename _Tp>
    class mem_fun_t : public unary_function<_Tp*, _Ret>
    {
    public:
      explicit
      mem_fun_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p) const
      { return (__p->*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
    };



  template<typename _Ret, typename _Tp>
    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
    {
    public:
      explicit
      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p) const
      { return (__p->*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    };



  template<typename _Ret, typename _Tp>
    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
    {
    public:
      explicit
      mem_fun_ref_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp& __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
  };



  template<typename _Ret, typename _Tp>
    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
    {
    public:
      explicit
      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp& __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
    {
    public:
      explicit
      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p, _Arg __x) const
      { return (__p->*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
    {
    public:
      explicit
      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p, _Arg __x) const
      { return (__p->*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    {
    public:
      explicit
      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp& __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    {
    public:
      explicit
      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp& __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    };



  template<typename _Ret, typename _Tp>
    inline mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)())
    { return mem_fun_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    inline const_mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    inline mem_fun_ref_t<_Ret, _Tp>
    mem_fun_ref(_Ret (_Tp::*__f)())
    { return mem_fun_ref_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    inline const_mem_fun_ref_t<_Ret, _Tp>
    mem_fun_ref(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }



}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/binders.h" 1 3
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/binders.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 97 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/binders.h" 3
  template<typename _Operation>
    class binder1st
    : public unary_function<typename _Operation::second_argument_type,
       typename _Operation::result_type>
    {
    public:
      _Operation op;
      typename _Operation::first_argument_type value;

    public:
      binder1st(const _Operation& __x,
  const typename _Operation::first_argument_type& __y)
      : op(__x), value(__y) { }

      typename _Operation::result_type
      operator()(const typename _Operation::second_argument_type& __x) const
      { return op(value, __x); }



      typename _Operation::result_type
      operator()(typename _Operation::second_argument_type& __x) const
      { return op(value, __x); }
    } ;


  template<typename _Operation, typename _Tp>
    inline binder1st<_Operation>
    bind1st(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::first_argument_type _Arg1_type;
      return binder1st<_Operation>(__fn, _Arg1_type(__x));
    }


  template<typename _Operation>
    class binder2nd
    : public unary_function<typename _Operation::first_argument_type,
       typename _Operation::result_type>
    {
    public:
      _Operation op;
      typename _Operation::second_argument_type value;

    public:
      binder2nd(const _Operation& __x,
  const typename _Operation::second_argument_type& __y)
      : op(__x), value(__y) { }

      typename _Operation::result_type
      operator()(const typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }



      typename _Operation::result_type
      operator()(typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }
    } ;


  template<typename _Operation, typename _Tp>
    inline binder2nd<_Operation>
    bind2nd(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::second_argument_type _Arg2_type;
      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
    }


}
# 713 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 2 3
# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/atomicity.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/atomicity.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 1 3
# 30 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 3
#pragma GCC visibility push(default)
# 162 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
# 1 "/usr/include/pthread.h" 1 3 4
# 25 "/usr/include/pthread.h" 3 4
# 1 "/usr/include/sched.h" 1 3 4
# 29 "/usr/include/sched.h" 3 4
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 30 "/usr/include/sched.h" 2 3 4


# 1 "/usr/include/time.h" 1 3 4
# 120 "/usr/include/time.h" 3 4
struct timespec
  {
    __time_t tv_sec;
    long int tv_nsec;
  };
# 33 "/usr/include/sched.h" 2 3 4


# 1 "/usr/include/bits/sched.h" 1 3 4
# 71 "/usr/include/bits/sched.h" 3 4
struct sched_param
  {
    int __sched_priority;
  };

extern "C" {



extern int clone (int (*__fn) (void *__arg), void *__child_stack,
    int __flags, void *__arg, ...) throw ();


extern int unshare (int __flags) throw ();


extern int sched_getcpu (void) throw ();


}







struct __sched_param
  {
    int __sched_priority;
  };
# 113 "/usr/include/bits/sched.h" 3 4
typedef unsigned long int __cpu_mask;






typedef struct
{
  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
# 196 "/usr/include/bits/sched.h" 3 4
extern "C" {

extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
  throw ();
extern cpu_set_t *__sched_cpualloc (size_t __count) throw () __attribute__ ((__warn_unused_result__));
extern void __sched_cpufree (cpu_set_t *__set) throw ();

}
# 36 "/usr/include/sched.h" 2 3 4




extern "C" {


extern int sched_setparam (__pid_t __pid, __const struct sched_param *__param)
     throw ();


extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();


extern int sched_setscheduler (__pid_t __pid, int __policy,
          __const struct sched_param *__param) throw ();


extern int sched_getscheduler (__pid_t __pid) throw ();


extern int sched_yield (void) throw ();


extern int sched_get_priority_max (int __algorithm) throw ();


extern int sched_get_priority_min (int __algorithm) throw ();


extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
# 110 "/usr/include/sched.h" 3 4
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
         __const cpu_set_t *__cpuset) throw ();


extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
         cpu_set_t *__cpuset) throw ();


}
# 26 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 30 "/usr/include/time.h" 3 4
extern "C" {







# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 39 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
# 43 "/usr/include/time.h" 2 3 4
# 58 "/usr/include/time.h" 3 4


typedef __clock_t clock_t;



# 74 "/usr/include/time.h" 3 4


typedef __time_t time_t;



# 92 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
# 104 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
# 131 "/usr/include/time.h" 3 4


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;


  long int tm_gmtoff;
  __const char *tm_zone;




};








struct itimerspec
  {
    struct timespec it_interval;
    struct timespec it_value;
  };


struct sigevent;





typedef __pid_t pid_t;








extern clock_t clock (void) throw ();


extern time_t time (time_t *__timer) throw ();


extern double difftime (time_t __time1, time_t __time0)
     throw () __attribute__ ((__const__));


extern time_t mktime (struct tm *__tp) throw ();





extern size_t strftime (char *__restrict __s, size_t __maxsize,
   __const char *__restrict __format,
   __const struct tm *__restrict __tp) throw ();





extern char *strptime (__const char *__restrict __s,
         __const char *__restrict __fmt, struct tm *__tp)
     throw ();







extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
     __const char *__restrict __format,
     __const struct tm *__restrict __tp,
     __locale_t __loc) throw ();



extern char *strptime_l (__const char *__restrict __s,
    __const char *__restrict __fmt, struct tm *__tp,
    __locale_t __loc) throw ();






extern struct tm *gmtime (__const time_t *__timer) throw ();



extern struct tm *localtime (__const time_t *__timer) throw ();





extern struct tm *gmtime_r (__const time_t *__restrict __timer,
       struct tm *__restrict __tp) throw ();



extern struct tm *localtime_r (__const time_t *__restrict __timer,
          struct tm *__restrict __tp) throw ();





extern char *asctime (__const struct tm *__tp) throw ();


extern char *ctime (__const time_t *__timer) throw ();







extern char *asctime_r (__const struct tm *__restrict __tp,
   char *__restrict __buf) throw ();


extern char *ctime_r (__const time_t *__restrict __timer,
        char *__restrict __buf) throw ();




extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;




extern char *tzname[2];



extern void tzset (void) throw ();



extern int daylight;
extern long int timezone;





extern int stime (__const time_t *__when) throw ();
# 313 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();


extern time_t timelocal (struct tm *__tp) throw ();


extern int dysize (int __year) throw () __attribute__ ((__const__));
# 328 "/usr/include/time.h" 3 4
extern int nanosleep (__const struct timespec *__requested_time,
        struct timespec *__remaining);



extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();


extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();


extern int clock_settime (clockid_t __clock_id, __const struct timespec *__tp)
     throw ();






extern int clock_nanosleep (clockid_t __clock_id, int __flags,
       __const struct timespec *__req,
       struct timespec *__rem);


extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();




extern int timer_create (clockid_t __clock_id,
    struct sigevent *__restrict __evp,
    timer_t *__restrict __timerid) throw ();


extern int timer_delete (timer_t __timerid) throw ();


extern int timer_settime (timer_t __timerid, int __flags,
     __const struct itimerspec *__restrict __value,
     struct itimerspec *__restrict __ovalue) throw ();


extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
     throw ();


extern int timer_getoverrun (timer_t __timerid) throw ();
# 390 "/usr/include/time.h" 3 4
extern int getdate_err;
# 399 "/usr/include/time.h" 3 4
extern struct tm *getdate (__const char *__string);
# 413 "/usr/include/time.h" 3 4
extern int getdate_r (__const char *__restrict __string,
        struct tm *__restrict __resbufp);


}
# 27 "/usr/include/pthread.h" 2 3 4


# 1 "/usr/include/signal.h" 1 3 4
# 31 "/usr/include/signal.h" 3 4
extern "C" {

# 1 "/usr/include/bits/sigset.h" 1 3 4
# 24 "/usr/include/bits/sigset.h" 3 4
typedef int __sig_atomic_t;




typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 34 "/usr/include/signal.h" 2 3 4
# 50 "/usr/include/signal.h" 3 4
typedef __sigset_t sigset_t;
# 408 "/usr/include/signal.h" 3 4
}
# 30 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4
# 50 "/usr/include/bits/pthreadtypes.h" 3 4
typedef unsigned long int pthread_t;


typedef union
{
  char __size[56];
  long int __align;
} pthread_attr_t;



typedef struct __pthread_internal_list
{
  struct __pthread_internal_list *__prev;
  struct __pthread_internal_list *__next;
} __pthread_list_t;
# 76 "/usr/include/bits/pthreadtypes.h" 3 4
typedef union
{
  struct __pthread_mutex_s
  {
    int __lock;
    unsigned int __count;
    int __owner;

    unsigned int __nusers;



    int __kind;

    int __spins;
    __pthread_list_t __list;
# 101 "/usr/include/bits/pthreadtypes.h" 3 4
  } __data;
  char __size[40];
  long int __align;
} pthread_mutex_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_mutexattr_t;




typedef union
{
  struct
  {
    int __lock;
    unsigned int __futex;
    __extension__ unsigned long long int __total_seq;
    __extension__ unsigned long long int __wakeup_seq;
    __extension__ unsigned long long int __woken_seq;
    void *__mutex;
    unsigned int __nwaiters;
    unsigned int __broadcast_seq;
  } __data;
  char __size[48];
  __extension__ long long int __align;
} pthread_cond_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_condattr_t;



typedef unsigned int pthread_key_t;



typedef int pthread_once_t;





typedef union
{

  struct
  {
    int __lock;
    unsigned int __nr_readers;
    unsigned int __readers_wakeup;
    unsigned int __writer_wakeup;
    unsigned int __nr_readers_queued;
    unsigned int __nr_writers_queued;
    int __writer;
    int __shared;
    unsigned long int __pad1;
    unsigned long int __pad2;


    unsigned int __flags;
  } __data;
# 187 "/usr/include/bits/pthreadtypes.h" 3 4
  char __size[56];
  long int __align;
} pthread_rwlock_t;

typedef union
{
  char __size[8];
  long int __align;
} pthread_rwlockattr_t;





typedef volatile int pthread_spinlock_t;




typedef union
{
  char __size[32];
  long int __align;
} pthread_barrier_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_barrierattr_t;
# 31 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/setjmp.h" 1 3 4
# 27 "/usr/include/bits/setjmp.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 28 "/usr/include/bits/setjmp.h" 2 3 4




typedef long int __jmp_buf[8];
# 32 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 33 "/usr/include/pthread.h" 2 3 4



enum
{
  PTHREAD_CREATE_JOINABLE,

  PTHREAD_CREATE_DETACHED

};



enum
{
  PTHREAD_MUTEX_TIMED_NP,
  PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_ADAPTIVE_NP

  ,
  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL



  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP

};




enum
{
  PTHREAD_MUTEX_STALLED,
  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
  PTHREAD_MUTEX_ROBUST,
  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};





enum
{
  PTHREAD_PRIO_NONE,
  PTHREAD_PRIO_INHERIT,
  PTHREAD_PRIO_PROTECT
};
# 117 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_RWLOCK_PREFER_READER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
};
# 149 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_INHERIT_SCHED,

  PTHREAD_EXPLICIT_SCHED

};



enum
{
  PTHREAD_SCOPE_SYSTEM,

  PTHREAD_SCOPE_PROCESS

};



enum
{
  PTHREAD_PROCESS_PRIVATE,

  PTHREAD_PROCESS_SHARED

};
# 184 "/usr/include/pthread.h" 3 4
struct _pthread_cleanup_buffer
{
  void (*__routine) (void *);
  void *__arg;
  int __canceltype;
  struct _pthread_cleanup_buffer *__prev;
};


enum
{
  PTHREAD_CANCEL_ENABLE,

  PTHREAD_CANCEL_DISABLE

};
enum
{
  PTHREAD_CANCEL_DEFERRED,

  PTHREAD_CANCEL_ASYNCHRONOUS

};
# 222 "/usr/include/pthread.h" 3 4
extern "C" {




extern int pthread_create (pthread_t *__restrict __newthread,
      __const pthread_attr_t *__restrict __attr,
      void *(*__start_routine) (void *),
      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));





extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));







extern int pthread_join (pthread_t __th, void **__thread_return);




extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();







extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
     __const struct timespec *__abstime);






extern int pthread_detach (pthread_t __th) throw ();



extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));


extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ();







extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_destroy (pthread_attr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr,
     int *__detachstate)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
     int __detachstate)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getguardsize (__const pthread_attr_t *__attr,
          size_t *__guardsize)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
          size_t __guardsize)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getschedparam (__const pthread_attr_t *__restrict
           __attr,
           struct sched_param *__restrict __param)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
           __const struct sched_param *__restrict
           __param) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__restrict
     __attr, int *__restrict __policy)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getinheritsched (__const pthread_attr_t *__restrict
      __attr, int *__restrict __inherit)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
      int __inherit)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getscope (__const pthread_attr_t *__restrict __attr,
      int *__restrict __scope)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getstackaddr (__const pthread_attr_t *__restrict
          __attr, void **__restrict __stackaddr)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));





extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
          void *__stackaddr)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));


extern int pthread_attr_getstacksize (__const pthread_attr_t *__restrict
          __attr, size_t *__restrict __stacksize)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
          size_t __stacksize)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,
      void **__restrict __stackaddr,
      size_t *__restrict __stacksize)
     throw () __attribute__ ((__nonnull__ (1, 2, 3)));




extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));





extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
     size_t __cpusetsize,
     __const cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (1, 3)));



extern int pthread_attr_getaffinity_np (__const pthread_attr_t *__attr,
     size_t __cpusetsize,
     cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (1, 3)));





extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
     throw () __attribute__ ((__nonnull__ (2)));







extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
      __const struct sched_param *__param)
     throw () __attribute__ ((__nonnull__ (3)));


extern int pthread_getschedparam (pthread_t __target_thread,
      int *__restrict __policy,
      struct sched_param *__restrict __param)
     throw () __attribute__ ((__nonnull__ (2, 3)));


extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
     throw ();




extern int pthread_getconcurrency (void) throw ();


extern int pthread_setconcurrency (int __level) throw ();







extern int pthread_yield (void) throw ();




extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
       __const cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (3)));


extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
       cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (3)));
# 468 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
# 480 "/usr/include/pthread.h" 3 4
extern int pthread_setcancelstate (int __state, int *__oldstate);



extern int pthread_setcanceltype (int __type, int *__oldtype);


extern int pthread_cancel (pthread_t __th);




extern void pthread_testcancel (void);




typedef struct
{
  struct
  {
    __jmp_buf __cancel_jmp_buf;
    int __mask_was_saved;
  } __cancel_jmp_buf[1];
  void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
# 514 "/usr/include/pthread.h" 3 4
struct __pthread_cleanup_frame
{
  void (*__cancel_routine) (void *);
  void *__cancel_arg;
  int __do_it;
  int __cancel_type;
};




class __pthread_cleanup_class
{
  void (*__cancel_routine) (void *);
  void *__cancel_arg;
  int __do_it;
  int __cancel_type;

 public:
  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
  void __setdoit (int __newval) { __do_it = __newval; }
  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
        &__cancel_type); }
  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
};
# 716 "/usr/include/pthread.h" 3 4
struct __jmp_buf_tag;
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();





extern int pthread_mutex_init (pthread_mutex_t *__mutex,
          __const pthread_mutexattr_t *__mutexattr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
                                    __const struct timespec *__restrict
                                    __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));




extern int pthread_mutex_getprioceiling (__const pthread_mutex_t *
      __restrict __mutex,
      int *__restrict __prioceiling)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
      int __prioceiling,
      int *__restrict __old_ceiling)
     throw () __attribute__ ((__nonnull__ (1, 3)));





extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));

extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));
# 782 "/usr/include/pthread.h" 3 4
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getpshared (__const pthread_mutexattr_t *
      __restrict __attr,
      int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
      int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict
          __attr, int *__restrict __kind)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getprotocol (__const pthread_mutexattr_t *
       __restrict __attr,
       int *__restrict __protocol)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
       int __protocol)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getprioceiling (__const pthread_mutexattr_t *
          __restrict __attr,
          int *__restrict __prioceiling)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
          int __prioceiling)
     throw () __attribute__ ((__nonnull__ (1)));




extern int pthread_mutexattr_getrobust (__const pthread_mutexattr_t *__attr,
     int *__robustness)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern int pthread_mutexattr_getrobust_np (__const pthread_mutexattr_t *__attr,
        int *__robustness)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
     int __robustness)
     throw () __attribute__ ((__nonnull__ (1)));

extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
        int __robustness)
     throw () __attribute__ ((__nonnull__ (1)));
# 864 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
    __const pthread_rwlockattr_t *__restrict
    __attr) throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
  throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
           __const struct timespec *__restrict
           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
           __const struct timespec *__restrict
           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));





extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
       int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getkind_np (__const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pref)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
       int __pref) throw () __attribute__ ((__nonnull__ (1)));







extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
         __const pthread_condattr_t *__restrict
         __cond_attr) throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_destroy (pthread_cond_t *__cond)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_signal (pthread_cond_t *__cond)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_broadcast (pthread_cond_t *__cond)
     throw () __attribute__ ((__nonnull__ (1)));






extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
         pthread_mutex_t *__restrict __mutex)
     __attribute__ ((__nonnull__ (1, 2)));
# 976 "/usr/include/pthread.h" 3 4
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
       pthread_mutex_t *__restrict __mutex,
       __const struct timespec *__restrict
       __abstime) __attribute__ ((__nonnull__ (1, 2, 3)));




extern int pthread_condattr_init (pthread_condattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_getpshared (__const pthread_condattr_t *
                                        __restrict __attr,
                                        int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
                                        int __pshared) throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_condattr_getclock (__const pthread_condattr_t *
          __restrict __attr,
          __clockid_t *__restrict __clock_id)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
          __clockid_t __clock_id)
     throw () __attribute__ ((__nonnull__ (1)));
# 1020 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_lock (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));






extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
     __const pthread_barrierattr_t *__restrict
     __attr, unsigned int __count)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_getpshared (__const pthread_barrierattr_t *
        __restrict __attr,
        int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
                                           int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));
# 1087 "/usr/include/pthread.h" 3 4
extern int pthread_key_create (pthread_key_t *__key,
          void (*__destr_function) (void *))
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_key_delete (pthread_key_t __key) throw ();


extern void *pthread_getspecific (pthread_key_t __key) throw ();


extern int pthread_setspecific (pthread_key_t __key,
    __const void *__pointer) throw () ;




extern int pthread_getcpuclockid (pthread_t __thread_id,
      __clockid_t *__clock_id)
     throw () __attribute__ ((__nonnull__ (2)));
# 1121 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
      void (*__parent) (void),
      void (*__child) (void)) throw ();




extern __inline __attribute__ ((__gnu_inline__)) int
pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ()
{
  return __thread1 == __thread2;
}


}
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3
# 1 "/usr/include/unistd.h" 1 3 4
# 28 "/usr/include/unistd.h" 3 4
extern "C" {
# 203 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/posix_opt.h" 1 3 4
# 204 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/bits/environments.h" 1 3 4
# 23 "/usr/include/bits/environments.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 24 "/usr/include/bits/environments.h" 2 3 4
# 208 "/usr/include/unistd.h" 2 3 4
# 221 "/usr/include/unistd.h" 3 4
typedef __ssize_t ssize_t;





# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 228 "/usr/include/unistd.h" 2 3 4





typedef __gid_t gid_t;




typedef __uid_t uid_t;





typedef __off_t off_t;






typedef __off64_t off64_t;




typedef __useconds_t useconds_t;
# 268 "/usr/include/unistd.h" 3 4
typedef __intptr_t intptr_t;






typedef __socklen_t socklen_t;
# 288 "/usr/include/unistd.h" 3 4
extern int access (__const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));




extern int euidaccess (__const char *__name, int __type)
     throw () __attribute__ ((__nonnull__ (1)));


extern int eaccess (__const char *__name, int __type)
     throw () __attribute__ ((__nonnull__ (1)));






extern int faccessat (int __fd, __const char *__file, int __type, int __flag)
     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
# 331 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
# 342 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
     throw ();






extern int close (int __fd);






extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __attribute__ ((__warn_unused_result__));





extern ssize_t write (int __fd, __const void *__buf, size_t __n) __attribute__ ((__warn_unused_result__));
# 373 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
        __off_t __offset) __attribute__ ((__warn_unused_result__));






extern ssize_t pwrite (int __fd, __const void *__buf, size_t __n,
         __off_t __offset) __attribute__ ((__warn_unused_result__));
# 401 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
   __off64_t __offset) __attribute__ ((__warn_unused_result__));


extern ssize_t pwrite64 (int __fd, __const void *__buf, size_t __n,
    __off64_t __offset) __attribute__ ((__warn_unused_result__));







extern int pipe (int __pipedes[2]) throw () __attribute__ ((__warn_unused_result__));




extern int pipe2 (int __pipedes[2], int __flags) throw () __attribute__ ((__warn_unused_result__));
# 429 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
# 441 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);






extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
     throw ();






extern int usleep (__useconds_t __useconds);
# 465 "/usr/include/unistd.h" 3 4
extern int pause (void);



extern int chown (__const char *__file, __uid_t __owner, __gid_t __group)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));



extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () __attribute__ ((__warn_unused_result__));




extern int lchown (__const char *__file, __uid_t __owner, __gid_t __group)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));






extern int fchownat (int __fd, __const char *__file, __uid_t __owner,
       __gid_t __group, int __flag)
     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));



extern int chdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));



extern int fchdir (int __fd) throw () __attribute__ ((__warn_unused_result__));
# 507 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) throw () __attribute__ ((__warn_unused_result__));





extern char *get_current_dir_name (void) throw ();






extern char *getwd (char *__buf)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__));




extern int dup (int __fd) throw () __attribute__ ((__warn_unused_result__));


extern int dup2 (int __fd, int __fd2) throw ();




extern int dup3 (int __fd, int __fd2, int __flags) throw ();



extern char **__environ;

extern char **environ;





extern int execve (__const char *__path, char *__const __argv[],
     char *__const __envp[]) throw () __attribute__ ((__nonnull__ (1)));




extern int fexecve (int __fd, char *__const __argv[], char *__const __envp[])
     throw ();




extern int execv (__const char *__path, char *__const __argv[])
     throw () __attribute__ ((__nonnull__ (1)));



extern int execle (__const char *__path, __const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1)));



extern int execl (__const char *__path, __const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1)));



extern int execvp (__const char *__file, char *__const __argv[])
     throw () __attribute__ ((__nonnull__ (1)));




extern int execlp (__const char *__file, __const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1)));




extern int execvpe (__const char *__file, char *__const __argv[],
      char *__const __envp[])
     throw () __attribute__ ((__nonnull__ (1)));





extern int nice (int __inc) throw () __attribute__ ((__warn_unused_result__));




extern void _exit (int __status) __attribute__ ((__noreturn__));





# 1 "/usr/include/bits/confname.h" 1 3 4
# 26 "/usr/include/bits/confname.h" 3 4
enum
  {
    _PC_LINK_MAX,

    _PC_MAX_CANON,

    _PC_MAX_INPUT,

    _PC_NAME_MAX,

    _PC_PATH_MAX,

    _PC_PIPE_BUF,

    _PC_CHOWN_RESTRICTED,

    _PC_NO_TRUNC,

    _PC_VDISABLE,

    _PC_SYNC_IO,

    _PC_ASYNC_IO,

    _PC_PRIO_IO,

    _PC_SOCK_MAXBUF,

    _PC_FILESIZEBITS,

    _PC_REC_INCR_XFER_SIZE,

    _PC_REC_MAX_XFER_SIZE,

    _PC_REC_MIN_XFER_SIZE,

    _PC_REC_XFER_ALIGN,

    _PC_ALLOC_SIZE_MIN,

    _PC_SYMLINK_MAX,

    _PC_2_SYMLINKS

  };


enum
  {
    _SC_ARG_MAX,

    _SC_CHILD_MAX,

    _SC_CLK_TCK,

    _SC_NGROUPS_MAX,

    _SC_OPEN_MAX,

    _SC_STREAM_MAX,

    _SC_TZNAME_MAX,

    _SC_JOB_CONTROL,

    _SC_SAVED_IDS,

    _SC_REALTIME_SIGNALS,

    _SC_PRIORITY_SCHEDULING,

    _SC_TIMERS,

    _SC_ASYNCHRONOUS_IO,

    _SC_PRIORITIZED_IO,

    _SC_SYNCHRONIZED_IO,

    _SC_FSYNC,

    _SC_MAPPED_FILES,

    _SC_MEMLOCK,

    _SC_MEMLOCK_RANGE,

    _SC_MEMORY_PROTECTION,

    _SC_MESSAGE_PASSING,

    _SC_SEMAPHORES,

    _SC_SHARED_MEMORY_OBJECTS,

    _SC_AIO_LISTIO_MAX,

    _SC_AIO_MAX,

    _SC_AIO_PRIO_DELTA_MAX,

    _SC_DELAYTIMER_MAX,

    _SC_MQ_OPEN_MAX,

    _SC_MQ_PRIO_MAX,

    _SC_VERSION,

    _SC_PAGESIZE,


    _SC_RTSIG_MAX,

    _SC_SEM_NSEMS_MAX,

    _SC_SEM_VALUE_MAX,

    _SC_SIGQUEUE_MAX,

    _SC_TIMER_MAX,




    _SC_BC_BASE_MAX,

    _SC_BC_DIM_MAX,

    _SC_BC_SCALE_MAX,

    _SC_BC_STRING_MAX,

    _SC_COLL_WEIGHTS_MAX,

    _SC_EQUIV_CLASS_MAX,

    _SC_EXPR_NEST_MAX,

    _SC_LINE_MAX,

    _SC_RE_DUP_MAX,

    _SC_CHARCLASS_NAME_MAX,


    _SC_2_VERSION,

    _SC_2_C_BIND,

    _SC_2_C_DEV,

    _SC_2_FORT_DEV,

    _SC_2_FORT_RUN,

    _SC_2_SW_DEV,

    _SC_2_LOCALEDEF,


    _SC_PII,

    _SC_PII_XTI,

    _SC_PII_SOCKET,

    _SC_PII_INTERNET,

    _SC_PII_OSI,

    _SC_POLL,

    _SC_SELECT,

    _SC_UIO_MAXIOV,

    _SC_IOV_MAX = _SC_UIO_MAXIOV,

    _SC_PII_INTERNET_STREAM,

    _SC_PII_INTERNET_DGRAM,

    _SC_PII_OSI_COTS,

    _SC_PII_OSI_CLTS,

    _SC_PII_OSI_M,

    _SC_T_IOV_MAX,



    _SC_THREADS,

    _SC_THREAD_SAFE_FUNCTIONS,

    _SC_GETGR_R_SIZE_MAX,

    _SC_GETPW_R_SIZE_MAX,

    _SC_LOGIN_NAME_MAX,

    _SC_TTY_NAME_MAX,

    _SC_THREAD_DESTRUCTOR_ITERATIONS,

    _SC_THREAD_KEYS_MAX,

    _SC_THREAD_STACK_MIN,

    _SC_THREAD_THREADS_MAX,

    _SC_THREAD_ATTR_STACKADDR,

    _SC_THREAD_ATTR_STACKSIZE,

    _SC_THREAD_PRIORITY_SCHEDULING,

    _SC_THREAD_PRIO_INHERIT,

    _SC_THREAD_PRIO_PROTECT,

    _SC_THREAD_PROCESS_SHARED,


    _SC_NPROCESSORS_CONF,

    _SC_NPROCESSORS_ONLN,

    _SC_PHYS_PAGES,

    _SC_AVPHYS_PAGES,

    _SC_ATEXIT_MAX,

    _SC_PASS_MAX,


    _SC_XOPEN_VERSION,

    _SC_XOPEN_XCU_VERSION,

    _SC_XOPEN_UNIX,

    _SC_XOPEN_CRYPT,

    _SC_XOPEN_ENH_I18N,

    _SC_XOPEN_SHM,


    _SC_2_CHAR_TERM,

    _SC_2_C_VERSION,

    _SC_2_UPE,


    _SC_XOPEN_XPG2,

    _SC_XOPEN_XPG3,

    _SC_XOPEN_XPG4,


    _SC_CHAR_BIT,

    _SC_CHAR_MAX,

    _SC_CHAR_MIN,

    _SC_INT_MAX,

    _SC_INT_MIN,

    _SC_LONG_BIT,

    _SC_WORD_BIT,

    _SC_MB_LEN_MAX,

    _SC_NZERO,

    _SC_SSIZE_MAX,

    _SC_SCHAR_MAX,

    _SC_SCHAR_MIN,

    _SC_SHRT_MAX,

    _SC_SHRT_MIN,

    _SC_UCHAR_MAX,

    _SC_UINT_MAX,

    _SC_ULONG_MAX,

    _SC_USHRT_MAX,


    _SC_NL_ARGMAX,

    _SC_NL_LANGMAX,

    _SC_NL_MSGMAX,

    _SC_NL_NMAX,

    _SC_NL_SETMAX,

    _SC_NL_TEXTMAX,


    _SC_XBS5_ILP32_OFF32,

    _SC_XBS5_ILP32_OFFBIG,

    _SC_XBS5_LP64_OFF64,

    _SC_XBS5_LPBIG_OFFBIG,


    _SC_XOPEN_LEGACY,

    _SC_XOPEN_REALTIME,

    _SC_XOPEN_REALTIME_THREADS,


    _SC_ADVISORY_INFO,

    _SC_BARRIERS,

    _SC_BASE,

    _SC_C_LANG_SUPPORT,

    _SC_C_LANG_SUPPORT_R,

    _SC_CLOCK_SELECTION,

    _SC_CPUTIME,

    _SC_THREAD_CPUTIME,

    _SC_DEVICE_IO,

    _SC_DEVICE_SPECIFIC,

    _SC_DEVICE_SPECIFIC_R,

    _SC_FD_MGMT,

    _SC_FIFO,

    _SC_PIPE,

    _SC_FILE_ATTRIBUTES,

    _SC_FILE_LOCKING,

    _SC_FILE_SYSTEM,

    _SC_MONOTONIC_CLOCK,

    _SC_MULTI_PROCESS,

    _SC_SINGLE_PROCESS,

    _SC_NETWORKING,

    _SC_READER_WRITER_LOCKS,

    _SC_SPIN_LOCKS,

    _SC_REGEXP,

    _SC_REGEX_VERSION,

    _SC_SHELL,

    _SC_SIGNALS,

    _SC_SPAWN,

    _SC_SPORADIC_SERVER,

    _SC_THREAD_SPORADIC_SERVER,

    _SC_SYSTEM_DATABASE,

    _SC_SYSTEM_DATABASE_R,

    _SC_TIMEOUTS,

    _SC_TYPED_MEMORY_OBJECTS,

    _SC_USER_GROUPS,

    _SC_USER_GROUPS_R,

    _SC_2_PBS,

    _SC_2_PBS_ACCOUNTING,

    _SC_2_PBS_LOCATE,

    _SC_2_PBS_MESSAGE,

    _SC_2_PBS_TRACK,

    _SC_SYMLOOP_MAX,

    _SC_STREAMS,

    _SC_2_PBS_CHECKPOINT,


    _SC_V6_ILP32_OFF32,

    _SC_V6_ILP32_OFFBIG,

    _SC_V6_LP64_OFF64,

    _SC_V6_LPBIG_OFFBIG,


    _SC_HOST_NAME_MAX,

    _SC_TRACE,

    _SC_TRACE_EVENT_FILTER,

    _SC_TRACE_INHERIT,

    _SC_TRACE_LOG,


    _SC_LEVEL1_ICACHE_SIZE,

    _SC_LEVEL1_ICACHE_ASSOC,

    _SC_LEVEL1_ICACHE_LINESIZE,

    _SC_LEVEL1_DCACHE_SIZE,

    _SC_LEVEL1_DCACHE_ASSOC,

    _SC_LEVEL1_DCACHE_LINESIZE,

    _SC_LEVEL2_CACHE_SIZE,

    _SC_LEVEL2_CACHE_ASSOC,

    _SC_LEVEL2_CACHE_LINESIZE,

    _SC_LEVEL3_CACHE_SIZE,

    _SC_LEVEL3_CACHE_ASSOC,

    _SC_LEVEL3_CACHE_LINESIZE,

    _SC_LEVEL4_CACHE_SIZE,

    _SC_LEVEL4_CACHE_ASSOC,

    _SC_LEVEL4_CACHE_LINESIZE,



    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,

    _SC_RAW_SOCKETS,


    _SC_V7_ILP32_OFF32,

    _SC_V7_ILP32_OFFBIG,

    _SC_V7_LP64_OFF64,

    _SC_V7_LPBIG_OFFBIG,


    _SC_SS_REPL_MAX,


    _SC_TRACE_EVENT_NAME_MAX,

    _SC_TRACE_NAME_MAX,

    _SC_TRACE_SYS_MAX,

    _SC_TRACE_USER_EVENT_MAX,


    _SC_XOPEN_STREAMS,


    _SC_THREAD_ROBUST_PRIO_INHERIT,

    _SC_THREAD_ROBUST_PRIO_PROTECT,

  };


enum
  {
    _CS_PATH,


    _CS_V6_WIDTH_RESTRICTED_ENVS,



    _CS_GNU_LIBC_VERSION,

    _CS_GNU_LIBPTHREAD_VERSION,


    _CS_V5_WIDTH_RESTRICTED_ENVS,



    _CS_V7_WIDTH_RESTRICTED_ENVS,



    _CS_LFS_CFLAGS = 1000,

    _CS_LFS_LDFLAGS,

    _CS_LFS_LIBS,

    _CS_LFS_LINTFLAGS,

    _CS_LFS64_CFLAGS,

    _CS_LFS64_LDFLAGS,

    _CS_LFS64_LIBS,

    _CS_LFS64_LINTFLAGS,


    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,

    _CS_XBS5_ILP32_OFF32_LDFLAGS,

    _CS_XBS5_ILP32_OFF32_LIBS,

    _CS_XBS5_ILP32_OFF32_LINTFLAGS,

    _CS_XBS5_ILP32_OFFBIG_CFLAGS,

    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,

    _CS_XBS5_ILP32_OFFBIG_LIBS,

    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,

    _CS_XBS5_LP64_OFF64_CFLAGS,

    _CS_XBS5_LP64_OFF64_LDFLAGS,

    _CS_XBS5_LP64_OFF64_LIBS,

    _CS_XBS5_LP64_OFF64_LINTFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_LIBS,

    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,


    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,

    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,

    _CS_POSIX_V6_ILP32_OFF32_LIBS,

    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,

    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,

    _CS_POSIX_V6_LP64_OFF64_CFLAGS,

    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,

    _CS_POSIX_V6_LP64_OFF64_LIBS,

    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,


    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,

    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,

    _CS_POSIX_V7_ILP32_OFF32_LIBS,

    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,

    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,

    _CS_POSIX_V7_LP64_OFF64_CFLAGS,

    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,

    _CS_POSIX_V7_LP64_OFF64_LIBS,

    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS

  };
# 605 "/usr/include/unistd.h" 2 3 4


extern long int pathconf (__const char *__path, int __name)
     throw () __attribute__ ((__nonnull__ (1)));


extern long int fpathconf (int __fd, int __name) throw ();


extern long int sysconf (int __name) throw ();



extern size_t confstr (int __name, char *__buf, size_t __len) throw ();




extern __pid_t getpid (void) throw ();


extern __pid_t getppid (void) throw ();




extern __pid_t getpgrp (void) throw ();
# 641 "/usr/include/unistd.h" 3 4
extern __pid_t __getpgid (__pid_t __pid) throw ();

extern __pid_t getpgid (__pid_t __pid) throw ();






extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
# 667 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();
# 684 "/usr/include/unistd.h" 3 4
extern __pid_t setsid (void) throw ();



extern __pid_t getsid (__pid_t __pid) throw ();



extern __uid_t getuid (void) throw ();


extern __uid_t geteuid (void) throw ();


extern __gid_t getgid (void) throw ();


extern __gid_t getegid (void) throw ();




extern int getgroups (int __size, __gid_t __list[]) throw () __attribute__ ((__warn_unused_result__));



extern int group_member (__gid_t __gid) throw ();






extern int setuid (__uid_t __uid) throw ();




extern int setreuid (__uid_t __ruid, __uid_t __euid) throw ();




extern int seteuid (__uid_t __uid) throw ();






extern int setgid (__gid_t __gid) throw ();




extern int setregid (__gid_t __rgid, __gid_t __egid) throw ();




extern int setegid (__gid_t __gid) throw ();





extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
     throw ();



extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
     throw ();



extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
     throw ();



extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
     throw ();






extern __pid_t fork (void) throw ();






extern __pid_t vfork (void) throw ();





extern char *ttyname (int __fd) throw ();



extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));



extern int isatty (int __fd) throw ();





extern int ttyslot (void) throw ();




extern int link (__const char *__from, __const char *__to)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));




extern int linkat (int __fromfd, __const char *__from, int __tofd,
     __const char *__to, int __flags)
     throw () __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__warn_unused_result__));




extern int symlink (__const char *__from, __const char *__to)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));




extern ssize_t readlink (__const char *__restrict __path,
    char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));




extern int symlinkat (__const char *__from, int __tofd,
        __const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));


extern ssize_t readlinkat (int __fd, __const char *__restrict __path,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));



extern int unlink (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));



extern int unlinkat (int __fd, __const char *__name, int __flag)
     throw () __attribute__ ((__nonnull__ (2)));



extern int rmdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1)));



extern __pid_t tcgetpgrp (int __fd) throw ();


extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();






extern char *getlogin (void);







extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));




extern int setlogin (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));
# 887 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/getopt.h" 1 3 4
# 50 "/usr/include/getopt.h" 3 4
extern "C" {
# 59 "/usr/include/getopt.h" 3 4
extern char *optarg;
# 73 "/usr/include/getopt.h" 3 4
extern int optind;




extern int opterr;



extern int optopt;
# 152 "/usr/include/getopt.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
       throw ();
# 187 "/usr/include/getopt.h" 3 4
}
# 888 "/usr/include/unistd.h" 2 3 4







extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));






extern int sethostname (__const char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));



extern int sethostid (long int __id) throw () __attribute__ ((__warn_unused_result__));





extern int getdomainname (char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int setdomainname (__const char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int vhangup (void) throw ();


extern int revoke (__const char *__file) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));







extern int profil (unsigned short int *__sample_buffer, size_t __size,
     size_t __offset, unsigned int __scale)
     throw () __attribute__ ((__nonnull__ (1)));





extern int acct (__const char *__name) throw ();



extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();





extern int daemon (int __nochdir, int __noclose) throw () __attribute__ ((__warn_unused_result__));






extern int chroot (__const char *__path) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));



extern char *getpass (__const char *__prompt) __attribute__ ((__nonnull__ (1)));
# 973 "/usr/include/unistd.h" 3 4
extern int fsync (int __fd);






extern long int gethostid (void);


extern void sync (void) throw ();




extern int getpagesize (void) throw () __attribute__ ((__const__));




extern int getdtablesize (void) throw ();




extern int truncate (__const char *__file, __off_t __length)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 1010 "/usr/include/unistd.h" 3 4
extern int truncate64 (__const char *__file, __off64_t __length)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 1020 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off_t __length) throw () __attribute__ ((__warn_unused_result__));
# 1030 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) throw () __attribute__ ((__warn_unused_result__));
# 1040 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) throw () __attribute__ ((__warn_unused_result__));





extern void *sbrk (intptr_t __delta) throw ();
# 1061 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
# 1084 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off_t __len) __attribute__ ((__warn_unused_result__));
# 1094 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) __attribute__ ((__warn_unused_result__));
# 1115 "/usr/include/unistd.h" 3 4
extern int fdatasync (int __fildes);







extern char *crypt (__const char *__key, __const char *__salt)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern void encrypt (char *__block, int __edflag) throw () __attribute__ ((__nonnull__ (1)));






extern void swab (__const void *__restrict __from, void *__restrict __to,
    ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));







extern char *ctermid (char *__s) throw ();





# 1 "/usr/include/bits/unistd.h" 1 3 4
# 24 "/usr/include/bits/unistd.h" 3 4
extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
      size_t __buflen) __attribute__ ((__warn_unused_result__));
extern ssize_t __read_alias (int __fd, void *__buf, size_t __nbytes) __asm__ ("" "read")
                               __attribute__ ((__warn_unused_result__));
extern ssize_t __read_chk_warn (int __fd, void *__buf, size_t __nbytes, size_t __buflen) __asm__ ("" "__read_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("read called with bigger length than size of " "the destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
read (int __fd, void *__buf, size_t __nbytes)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
 return __read_chk (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));

      if (__nbytes > __builtin_object_size (__buf, 0))
 return __read_chk_warn (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
    }
  return __read_alias (__fd, __buf, __nbytes);
}


extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
       __off_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
         __off64_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
extern ssize_t __pread_alias (int __fd, void *__buf, size_t __nbytes, __off_t __offset) __asm__ ("" "pread")

                                 __attribute__ ((__warn_unused_result__));
extern ssize_t __pread64_alias (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")

                                     __attribute__ ((__warn_unused_result__));
extern ssize_t __pread_chk_warn (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __asm__ ("" "__pread_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread called with bigger length than size of " "the destination buffer")))
                                  ;
extern ssize_t __pread64_chk_warn (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize) __asm__ ("" "__pread64_chk")



     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread64 called with bigger length than size of " "the destination buffer")))
                                  ;


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
 return __pread_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));

      if ( __nbytes > __builtin_object_size (__buf, 0))
 return __pread_chk_warn (__fd, __buf, __nbytes, __offset,
     __builtin_object_size (__buf, 0));
    }
  return __pread_alias (__fd, __buf, __nbytes, __offset);
}
# 105 "/usr/include/bits/unistd.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
 return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));

      if ( __nbytes > __builtin_object_size (__buf, 0))
 return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
       __builtin_object_size (__buf, 0));
    }

  return __pread64_alias (__fd, __buf, __nbytes, __offset);
}




extern ssize_t __readlink_chk (__const char *__restrict __path,
          char *__restrict __buf, size_t __len,
          size_t __buflen)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlink_alias (__const char *__restrict __path, char *__restrict __buf, size_t __len) throw () __asm__ ("" "readlink")


     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlink_chk_warn (__const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__readlink_chk")



     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlink called with bigger length " "than size of destination buffer")))
                                         ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) ssize_t
readlink (__const char *__restrict __path, char *__restrict __buf, size_t __len) throw ()

{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __readlink_chk (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));

      if ( __len > __builtin_object_size (__buf, 2 > 1))
 return __readlink_chk_warn (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
    }
  return __readlink_alias (__path, __buf, __len);
}



extern ssize_t __readlinkat_chk (int __fd, __const char *__restrict __path,
     char *__restrict __buf, size_t __len,
     size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlinkat_alias (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len) throw () __asm__ ("" "readlinkat")



     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlinkat_chk_warn (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__readlinkat_chk")



     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlinkat called with bigger " "length than size of destination " "buffer")))

                ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) ssize_t
readlinkat (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len) throw ()

{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __readlinkat_chk (__fd, __path, __buf, __len, __builtin_object_size (__buf, 2 > 1));

      if (__len > __builtin_object_size (__buf, 2 > 1))
 return __readlinkat_chk_warn (__fd, __path, __buf, __len,
          __builtin_object_size (__buf, 2 > 1));
    }
  return __readlinkat_alias (__fd, __path, __buf, __len);
}


extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen)
     throw () __attribute__ ((__warn_unused_result__));
extern char *__getcwd_alias (char *__buf, size_t __size) throw () __asm__ ("" "getcwd")
                                              __attribute__ ((__warn_unused_result__));
extern char *__getcwd_chk_warn (char *__buf, size_t __size, size_t __buflen) throw () __asm__ ("" "__getcwd_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getcwd caller with bigger length than size of " "destination buffer")))
                              ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
getcwd (char *__buf, size_t __size) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size))
 return __getcwd_chk (__buf, __size, __builtin_object_size (__buf, 2 > 1));

      if (__size > __builtin_object_size (__buf, 2 > 1))
 return __getcwd_chk_warn (__buf, __size, __builtin_object_size (__buf, 2 > 1));
    }
  return __getcwd_alias (__buf, __size);
}


extern char *__getwd_chk (char *__buf, size_t buflen)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern char *__getwd_warn (char *__buf) throw () __asm__ ("" "getwd")
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use getcwd instead, as getwd " "doesn't specify buffer size")))
                                         ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__)) char *
getwd (char *__buf) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    return __getwd_chk (__buf, __builtin_object_size (__buf, 2 > 1));
  return __getwd_warn (__buf);
}


extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
        size_t __buflen) throw ();
extern size_t __confstr_alias (int __name, char *__buf, size_t __len) throw () __asm__ ("" "confstr")
                             ;
extern size_t __confstr_chk_warn (int __name, char *__buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__confstr_chk")


     __attribute__((__warning__ ("confstr called with bigger length than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
confstr (int __name, char *__buf, size_t __len) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __confstr_chk (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));

      if (__builtin_object_size (__buf, 2 > 1) < __len)
 return __confstr_chk_warn (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
    }
  return __confstr_alias (__name, __buf, __len);
}


extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
     throw () __attribute__ ((__warn_unused_result__));
extern int __getgroups_alias (int __size, __gid_t __list[]) throw () __asm__ ("" "getgroups")
                 __attribute__ ((__warn_unused_result__));
extern int __getgroups_chk_warn (int __size, __gid_t __list[], size_t __listlen) throw () __asm__ ("" "__getgroups_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getgroups called with bigger group count than what " "can fit into destination buffer")))
                                           ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
getgroups (int __size, __gid_t __list[]) throw ()
{
  if (__builtin_object_size (__list, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size) || __size < 0)
 return __getgroups_chk (__size, __list, __builtin_object_size (__list, 2 > 1));

      if (__size * sizeof (__gid_t) > __builtin_object_size (__list, 2 > 1))
 return __getgroups_chk_warn (__size, __list, __builtin_object_size (__list, 2 > 1));
    }
  return __getgroups_alias (__size, __list);
}


extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
       size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
extern int __ttyname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ttyname_r")

     __attribute__ ((__nonnull__ (2)));
extern int __ttyname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ttyname_r_chk")


     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ttyname_r called with bigger buflen than " "size of destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
ttyname_r (int __fd, char *__buf, size_t __buflen) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __ttyname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __ttyname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __ttyname_r_alias (__fd, __buf, __buflen);
}



extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
     __attribute__ ((__nonnull__ (1)));
extern int __getlogin_r_alias (char *__buf, size_t __buflen) __asm__ ("" "getlogin_r")
                     __attribute__ ((__nonnull__ (1)));
extern int __getlogin_r_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getlogin_r_chk")


     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("getlogin_r called with bigger buflen than " "size of destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
getlogin_r (char *__buf, size_t __buflen)
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __getlogin_r_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __getlogin_r_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __getlogin_r_alias (__buf, __buflen);
}




extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
     throw () __attribute__ ((__nonnull__ (1)));
extern int __gethostname_alias (char *__buf, size_t __buflen) throw () __asm__ ("" "gethostname")
                   __attribute__ ((__nonnull__ (1)));
extern int __gethostname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__gethostname_chk")


     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("gethostname called with bigger buflen than " "size of destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
gethostname (char *__buf, size_t __buflen) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __gethostname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __gethostname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __gethostname_alias (__buf, __buflen);
}




extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int __getdomainname_alias (char *__buf, size_t __buflen) throw () __asm__ ("" "getdomainname")

                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int __getdomainname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__getdomainname_chk")


     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getdomainname called with bigger " "buflen than size of destination " "buffer")))

                    ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
getdomainname (char *__buf, size_t __buflen) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __getdomainname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __getdomainname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __getdomainname_alias (__buf, __buflen);
}
# 1151 "/usr/include/unistd.h" 2 3 4


}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3

typedef pthread_t __gthread_t;
typedef pthread_key_t __gthread_key_t;
typedef pthread_once_t __gthread_once_t;
typedef pthread_mutex_t __gthread_mutex_t;
typedef pthread_mutex_t __gthread_recursive_mutex_t;
typedef pthread_cond_t __gthread_cond_t;
typedef struct timespec __gthread_time_t;
# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));

static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));

static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));


static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));


static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));

static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));


static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
# 237 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
  static void *const __gthread_active_ptr
    = __extension__ (void *) &__gthrw_pthread_cancel;
  return __gthread_active_ptr != 0;
}
# 675 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
    void *__args)
{
  return __gthrw_pthread_create (__threadid, __null, __func, __args);
}

static inline int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
{
  return __gthrw_pthread_join (__threadid, __value_ptr);
}

static inline int
__gthread_detach (__gthread_t __threadid)
{
  return __gthrw_pthread_detach (__threadid);
}

static inline int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
  return __gthrw_pthread_equal (__t1, __t2);
}

static inline __gthread_t
__gthread_self (void)
{
  return __gthrw_pthread_self ();
}

static inline int
__gthread_yield (void)
{
  return __gthrw_sched_yield ();
}

static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
  if (__gthread_active_p ())
    return __gthrw_pthread_once (__once, __func);
  else
    return -1;
}

static inline int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
  return __gthrw_pthread_key_create (__key, __dtor);
}

static inline int
__gthread_key_delete (__gthread_key_t __key)
{
  return __gthrw_pthread_key_delete (__key);
}

static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
  return __gthrw_pthread_getspecific (__key);
}

static inline int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
  return __gthrw_pthread_setspecific (__key, __ptr);
}

static inline int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_destroy (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_lock (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_trylock (__mutex);
  else
    return 0;
}



static inline int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
      const __gthread_time_t *__abs_timeout)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
  else
    return 0;
}



static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_unlock (__mutex);
  else
    return 0;
}
# 818 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
  return __gthread_mutex_lock (__mutex);
}

static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
  return __gthread_mutex_trylock (__mutex);
}



static inline int
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
         const __gthread_time_t *__abs_timeout)
{
  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
}



static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
  return __gthread_mutex_unlock (__mutex);
}

static inline int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
  return __gthrw_pthread_cond_broadcast (__cond);
}

static inline int
__gthread_cond_signal (__gthread_cond_t *__cond)
{
  return __gthrw_pthread_cond_signal (__cond);
}

static inline int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
  return __gthrw_pthread_cond_wait (__cond, __mutex);
}

static inline int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
     const __gthread_time_t *__abs_timeout)
{
  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}

static inline int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
          __gthread_recursive_mutex_t *__mutex)
{
  return __gthread_cond_wait (__cond, __mutex);
}

static inline int
__gthread_cond_timedwait_recursive (__gthread_cond_t *__cond,
        __gthread_recursive_mutex_t *__mutex,
        const __gthread_time_t *__abs_timeout)
{
  return __gthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}

static inline int
__gthread_cond_destroy (__gthread_cond_t* __cond)
{
  return __gthrw_pthread_cond_destroy (__cond);
}
# 163 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 2 3







#pragma GCC visibility pop
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/atomicity.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3
# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/atomic_word.h" 3
typedef int _Atomic_word;
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/atomicity.h" 2 3

namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {






  static inline _Atomic_word
  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
  { return __sync_fetch_and_add(__mem, __val); }

  static inline void
  __atomic_add(volatile _Atomic_word* __mem, int __val)
  { __sync_fetch_and_add(__mem, __val); }
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/atomicity.h" 3
  static inline _Atomic_word
  __exchange_and_add_single(_Atomic_word* __mem, int __val)
  {
    _Atomic_word __result = *__mem;
    *__mem += __val;
    return __result;
  }

  static inline void
  __atomic_add_single(_Atomic_word* __mem, int __val)
  { *__mem += __val; }

  static inline _Atomic_word
  __attribute__ ((__unused__))
  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
  {

    if (__gthread_active_p())
      return __exchange_and_add(__mem, __val);
    else
      return __exchange_and_add_single(__mem, __val);



  }

  static inline void
  __attribute__ ((__unused__))
  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
  {

    if (__gthread_active_p())
      __atomic_add(__mem, __val);
    else
      __atomic_add_single(__mem, __val);



  }

}
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 2 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/initializer_list" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/initializer_list" 3
       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/initializer_list" 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 103 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_string
    {
      typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;


    public:
      typedef _Traits traits_type;
      typedef typename _Traits::char_type value_type;
      typedef _Alloc allocator_type;
      typedef typename _CharT_alloc_type::size_type size_type;
      typedef typename _CharT_alloc_type::difference_type difference_type;
      typedef typename _CharT_alloc_type::reference reference;
      typedef typename _CharT_alloc_type::const_reference const_reference;
      typedef typename _CharT_alloc_type::pointer pointer;
      typedef typename _CharT_alloc_type::const_pointer const_pointer;
      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
                                                            const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;

    private:
# 140 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      struct _Rep_base
      {
 size_type _M_length;
 size_type _M_capacity;
 _Atomic_word _M_refcount;
      };

      struct _Rep : _Rep_base
      {

 typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
# 165 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
 static const size_type _S_max_size;
 static const _CharT _S_terminal;



        static size_type _S_empty_rep_storage[];

        static _Rep&
        _S_empty_rep()
        {



   void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
   return *reinterpret_cast<_Rep*>(__p);
 }

        bool
 _M_is_leaked() const
        { return this->_M_refcount < 0; }

        bool
 _M_is_shared() const
        { return this->_M_refcount > 0; }

        void
 _M_set_leaked()
        { this->_M_refcount = -1; }

        void
 _M_set_sharable()
        { this->_M_refcount = 0; }

 void
 _M_set_length_and_sharable(size_type __n)
 {

   if (__builtin_expect(this != &_S_empty_rep(), false))

     {
       this->_M_set_sharable();
       this->_M_length = __n;
       traits_type::assign(this->_M_refdata()[__n], _S_terminal);


     }
 }

 _CharT*
 _M_refdata() throw()
 { return reinterpret_cast<_CharT*>(this + 1); }

 _CharT*
 _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
 {
   return (!_M_is_leaked() && __alloc1 == __alloc2)
           ? _M_refcopy() : _M_clone(__alloc1);
 }


 static _Rep*
 _S_create(size_type, size_type, const _Alloc&);

 void
 _M_dispose(const _Alloc& __a)
 {

   if (__builtin_expect(this != &_S_empty_rep(), false))

     if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
             -1) <= 0)
       _M_destroy(__a);
 }

 void
 _M_destroy(const _Alloc&) throw();

 _CharT*
 _M_refcopy() throw()
 {

   if (__builtin_expect(this != &_S_empty_rep(), false))

            __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
   return _M_refdata();
 }

 _CharT*
 _M_clone(const _Alloc&, size_type __res = 0);
      };


      struct _Alloc_hider : _Alloc
      {
 _Alloc_hider(_CharT* __dat, const _Alloc& __a)
 : _Alloc(__a), _M_p(__dat) { }

 _CharT* _M_p;
      };

    public:




      static const size_type npos = static_cast<size_type>(-1);

    private:

      mutable _Alloc_hider _M_dataplus;

      _CharT*
      _M_data() const
      { return _M_dataplus._M_p; }

      _CharT*
      _M_data(_CharT* __p)
      { return (_M_dataplus._M_p = __p); }

      _Rep*
      _M_rep() const
      { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }



      iterator
      _M_ibegin() const
      { return iterator(_M_data()); }

      iterator
      _M_iend() const
      { return iterator(_M_data() + this->size()); }

      void
      _M_leak()
      {
 if (!_M_rep()->_M_is_leaked())
   _M_leak_hard();
      }

      size_type
      _M_check(size_type __pos, const char* __s) const
      {
 if (__pos > this->size())
   __throw_out_of_range((__s));
 return __pos;
      }

      void
      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
      {
 if (this->max_size() - (this->size() - __n1) < __n2)
   __throw_length_error((__s));
      }


      size_type
      _M_limit(size_type __pos, size_type __off) const
      {
 const bool __testoff = __off < this->size() - __pos;
 return __testoff ? __off : this->size() - __pos;
      }


      bool
      _M_disjunct(const _CharT* __s) const
      {
 return (less<const _CharT*>()(__s, _M_data())
  || less<const _CharT*>()(_M_data() + this->size(), __s));
      }



      static void
      _M_copy(_CharT* __d, const _CharT* __s, size_type __n)
      {
 if (__n == 1)
   traits_type::assign(*__d, *__s);
 else
   traits_type::copy(__d, __s, __n);
      }

      static void
      _M_move(_CharT* __d, const _CharT* __s, size_type __n)
      {
 if (__n == 1)
   traits_type::assign(*__d, *__s);
 else
   traits_type::move(__d, __s, __n);
      }

      static void
      _M_assign(_CharT* __d, size_type __n, _CharT __c)
      {
 if (__n == 1)
   traits_type::assign(*__d, __c);
 else
   traits_type::assign(__d, __n, __c);
      }



      template<class _Iterator>
        static void
        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
        {
   for (; __k1 != __k2; ++__k1, ++__p)
     traits_type::assign(*__p, *__k1);
 }

      static void
      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      static void
      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      static void
      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
      { _M_copy(__p, __k1, __k2 - __k1); }

      static void
      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
      { _M_copy(__p, __k1, __k2 - __k1); }

      static int
      _S_compare(size_type __n1, size_type __n2)
      {
 const difference_type __d = difference_type(__n1 - __n2);

 if (__d > __gnu_cxx::__numeric_traits<int>::__max)
   return __gnu_cxx::__numeric_traits<int>::__max;
 else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
   return __gnu_cxx::__numeric_traits<int>::__min;
 else
   return int(__d);
      }

      void
      _M_mutate(size_type __pos, size_type __len1, size_type __len2);

      void
      _M_leak_hard();

      static _Rep&
      _S_empty_rep()
      { return _Rep::_S_empty_rep(); }

    public:







      basic_string()

      : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }







      explicit
      basic_string(const _Alloc& __a);






      basic_string(const basic_string& __str);






      basic_string(const basic_string& __str, size_type __pos,
     size_type __n = npos);







      basic_string(const basic_string& __str, size_type __pos,
     size_type __n, const _Alloc& __a);
# 468 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string(const _CharT* __s, size_type __n,
     const _Alloc& __a = _Alloc());





      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());






      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
# 516 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string(_InputIterator __beg, _InputIterator __end,
       const _Alloc& __a = _Alloc());




      ~basic_string()
      { _M_rep()->_M_dispose(this->get_allocator()); }





      basic_string&
      operator=(const basic_string& __str)
      { return this->assign(__str); }





      basic_string&
      operator=(const _CharT* __s)
      { return this->assign(__s); }
# 549 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      operator=(_CharT __c)
      {
 this->assign(1, __c);
 return *this;
      }
# 589 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      iterator
      begin()
      {
 _M_leak();
 return iterator(_M_data());
      }





      const_iterator
      begin() const
      { return const_iterator(_M_data()); }





      iterator
      end()
      {
 _M_leak();
 return iterator(_M_data() + this->size());
      }





      const_iterator
      end() const
      { return const_iterator(_M_data() + this->size()); }






      reverse_iterator
      rbegin()
      { return reverse_iterator(this->end()); }






      const_reverse_iterator
      rbegin() const
      { return const_reverse_iterator(this->end()); }






      reverse_iterator
      rend()
      { return reverse_iterator(this->begin()); }






      const_reverse_iterator
      rend() const
      { return const_reverse_iterator(this->begin()); }
# 695 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
    public:



      size_type
      size() const
      { return _M_rep()->_M_length; }



      size_type
      length() const
      { return _M_rep()->_M_length; }


      size_type
      max_size() const
      { return _Rep::_S_max_size; }
# 724 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      void
      resize(size_type __n, _CharT __c);
# 737 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      void
      resize(size_type __n)
      { this->resize(__n, _CharT()); }
# 757 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      capacity() const
      { return _M_rep()->_M_capacity; }
# 778 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      void
      reserve(size_type __res_arg = 0);




      void
      clear()
      { _M_mutate(0, this->size(), 0); }





      bool
      empty() const
      { return this->size() == 0; }
# 807 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      const_reference
      operator[] (size_type __pos) const
      {
 ;
 return _M_data()[__pos];
      }
# 824 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      reference
      operator[](size_type __pos)
      {

 ;

 ;
 _M_leak();
 return _M_data()[__pos];
      }
# 845 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      const_reference
      at(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range(("basic_string::at"));
 return _M_data()[__n];
      }
# 864 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      reference
      at(size_type __n)
      {
 if (__n >= size())
   __throw_out_of_range(("basic_string::at"));
 _M_leak();
 return _M_data()[__n];
      }







      basic_string&
      operator+=(const basic_string& __str)
      { return this->append(__str); }






      basic_string&
      operator+=(const _CharT* __s)
      { return this->append(__s); }






      basic_string&
      operator+=(_CharT __c)
      {
 this->push_back(__c);
 return *this;
      }
# 920 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      append(const basic_string& __str);
# 935 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      append(const basic_string& __str, size_type __pos, size_type __n);







      basic_string&
      append(const _CharT* __s, size_type __n);






      basic_string&
      append(const _CharT* __s)
      {
 ;
 return this->append(__s, traits_type::length(__s));
      }
# 967 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      append(size_type __n, _CharT __c);
# 989 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string&
        append(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_iend(), _M_iend(), __first, __last); }





      void
      push_back(_CharT __c)
      {
 const size_type __len = 1 + this->size();
 if (__len > this->capacity() || _M_rep()->_M_is_shared())
   this->reserve(__len);
 traits_type::assign(_M_data()[this->size()], __c);
 _M_rep()->_M_set_length_and_sharable(__len);
      }






      basic_string&
      assign(const basic_string& __str);
# 1045 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      assign(const basic_string& __str, size_type __pos, size_type __n)
      { return this->assign(__str._M_data()
       + __str._M_check(__pos, "basic_string::assign"),
       __str._M_limit(__pos, __n)); }
# 1061 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s, size_type __n);
# 1073 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s)
      {
 ;
 return this->assign(__s, traits_type::length(__s));
      }
# 1089 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      assign(size_type __n, _CharT __c)
      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 1101 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string&
        assign(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
# 1129 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      void
      insert(iterator __p, size_type __n, _CharT __c)
      { this->replace(__p, __p, __n, __c); }
# 1144 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      template<class _InputIterator>
        void
        insert(iterator __p, _InputIterator __beg, _InputIterator __end)
        { this->replace(__p, __p, __beg, __end); }
# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos1, const basic_string& __str)
      { return this->insert(__pos1, __str, size_type(0), __str.size()); }
# 1197 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos1, const basic_string& __str,
      size_type __pos2, size_type __n)
      { return this->insert(__pos1, __str._M_data()
       + __str._M_check(__pos2, "basic_string::insert"),
       __str._M_limit(__pos2, __n)); }
# 1220 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n);
# 1238 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s)
      {
 ;
 return this->insert(__pos, __s, traits_type::length(__s));
      }
# 1261 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, size_type __n, _CharT __c)
      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
         size_type(0), __n, __c); }
# 1278 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      iterator
      insert(iterator __p, _CharT __c)
      {
 ;
 const size_type __pos = __p - _M_ibegin();
 _M_replace_aux(__pos, size_type(0), size_type(1), __c);
 _M_rep()->_M_set_leaked();
 return iterator(_M_data() + __pos);
      }
# 1302 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      erase(size_type __pos = 0, size_type __n = npos)
      {
 _M_mutate(_M_check(__pos, "basic_string::erase"),
    _M_limit(__pos, __n), size_type(0));
 return *this;
      }
# 1318 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      iterator
      erase(iterator __position)
      {

                               ;
 const size_type __pos = __position - _M_ibegin();
 _M_mutate(__pos, size_type(1), size_type(0));
 _M_rep()->_M_set_leaked();
 return iterator(_M_data() + __pos);
      }
# 1338 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 1357 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n, const basic_string& __str)
      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
# 1379 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2)
      { return this->replace(__pos1, __n1, __str._M_data()
        + __str._M_check(__pos2, "basic_string::replace"),
        __str._M_limit(__pos2, __n2)); }
# 1403 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2);
# 1422 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s)
      {
 ;
 return this->replace(__pos, __n1, __s, traits_type::length(__s));
      }
# 1445 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
         _M_limit(__pos, __n1), __n2, __c); }
# 1463 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, const basic_string& __str)
      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
# 1481 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
      {

                          ;
 return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
      }
# 1502 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, const _CharT* __s)
      {
 ;
 return this->replace(__i1, __i2, __s, traits_type::length(__s));
      }
# 1523 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
      {

                          ;
 return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
      }
# 1545 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string&
        replace(iterator __i1, iterator __i2,
  _InputIterator __k1, _InputIterator __k2)
        {
  
                            ;
   ;
   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
 }



      basic_string&
      replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
      {

                          ;
 ;
 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
        __k1, __k2 - __k1);
      }

      basic_string&
      replace(iterator __i1, iterator __i2,
       const _CharT* __k1, const _CharT* __k2)
      {

                          ;
 ;
 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
        __k1, __k2 - __k1);
      }

      basic_string&
      replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
      {

                          ;
 ;
 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
        __k1.base(), __k2 - __k1);
      }

      basic_string&
      replace(iterator __i1, iterator __i2,
       const_iterator __k1, const_iterator __k2)
      {

                          ;
 ;
 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
        __k1.base(), __k2 - __k1);
      }
# 1620 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
    private:
      template<class _Integer>
 basic_string&
 _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
       _Integer __val, __true_type)
        { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }

      template<class _InputIterator>
 basic_string&
 _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
       _InputIterator __k2, __false_type);

      basic_string&
      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
       _CharT __c);

      basic_string&
      _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
        size_type __n2);



      template<class _InIterator>
        static _CharT*
        _S_construct_aux(_InIterator __beg, _InIterator __end,
    const _Alloc& __a, __false_type)
 {
          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
          return _S_construct(__beg, __end, __a, _Tag());
 }



      template<class _Integer>
        static _CharT*
        _S_construct_aux(_Integer __beg, _Integer __end,
    const _Alloc& __a, __true_type)
        { return _S_construct_aux_2(static_cast<size_type>(__beg),
        __end, __a); }

      static _CharT*
      _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
      { return _S_construct(__req, __c, __a); }

      template<class _InIterator>
        static _CharT*
        _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
 {
   typedef typename std::__is_integer<_InIterator>::__type _Integral;
   return _S_construct_aux(__beg, __end, __a, _Integral());
        }


      template<class _InIterator>
        static _CharT*
         _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
        input_iterator_tag);



      template<class _FwdIterator>
        static _CharT*
        _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
       forward_iterator_tag);

      static _CharT*
      _S_construct(size_type __req, _CharT __c, const _Alloc& __a);

    public:
# 1701 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 1711 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      void
      swap(basic_string& __s);
# 1721 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      const _CharT*
      c_str() const
      { return _M_data(); }







      const _CharT*
      data() const
      { return _M_data(); }




      allocator_type
      get_allocator() const
      { return _M_dataplus; }
# 1753 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const;
# 1766 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find(const basic_string& __str, size_type __pos = 0) const
      { return this->find(__str.data(), __pos, __str.size()); }
# 1780 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos = 0) const
      {
 ;
 return this->find(__s, __pos, traits_type::length(__s));
      }
# 1797 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find(_CharT __c, size_type __pos = 0) const;
# 1810 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      rfind(const basic_string& __str, size_type __pos = npos) const
      { return this->rfind(__str.data(), __pos, __str.size()); }
# 1825 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
# 1838 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos = npos) const
      {
 ;
 return this->rfind(__s, __pos, traits_type::length(__s));
      }
# 1855 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      rfind(_CharT __c, size_type __pos = npos) const;
# 1868 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_of(const basic_string& __str, size_type __pos = 0) const
      { return this->find_first_of(__str.data(), __pos, __str.size()); }
# 1883 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 1896 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos = 0) const
      {
 ;
 return this->find_first_of(__s, __pos, traits_type::length(__s));
      }
# 1915 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const
      { return this->find(__c, __pos); }
# 1929 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_of(const basic_string& __str, size_type __pos = npos) const
      { return this->find_last_of(__str.data(), __pos, __str.size()); }
# 1944 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 1957 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos = npos) const
      {
 ;
 return this->find_last_of(__s, __pos, traits_type::length(__s));
      }
# 1976 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const
      { return this->rfind(__c, __pos); }
# 1990 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
# 2005 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
   size_type __n) const;
# 2019 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
      {
 ;
 return this->find_first_not_of(__s, __pos, traits_type::length(__s));
      }
# 2036 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const;
# 2049 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
# 2065 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
         size_type __n) const;
# 2078 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
      {
 ;
 return this->find_last_not_of(__s, __pos, traits_type::length(__s));
      }
# 2095 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const;
# 2110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      basic_string
      substr(size_type __pos = 0, size_type __n = npos) const
      { return basic_string(*this,
       _M_check(__pos, "basic_string::substr"), __n); }
# 2128 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      int
      compare(const basic_string& __str) const
      {
 const size_type __size = this->size();
 const size_type __osize = __str.size();
 const size_type __len = std::min(__size, __osize);

 int __r = traits_type::compare(_M_data(), __str.data(), __len);
 if (!__r)
   __r = _S_compare(__size, __osize);
 return __r;
      }
# 2158 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;
# 2182 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2) const;
# 2200 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      int
      compare(const _CharT* __s) const;
# 2223 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
# 2248 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2) const;
  };
# 2260 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(const _CharT* __lhs,
       const basic_string<_CharT,_Traits,_Alloc>& __rhs);







  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
      const _CharT* __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __string_type __str(__lhs);
      __str.append(__size_type(1), __rhs);
      return __str;
    }
# 2331 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) == 0; }

  template<typename _CharT>
    inline
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
    operator==(const basic_string<_CharT>& __lhs,
        const basic_string<_CharT>& __rhs)
    { return (__lhs.size() == __rhs.size()
       && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
          __lhs.size())); }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const _CharT* __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) == 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return __lhs.compare(__rhs) == 0; }
# 2377 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return !(__lhs == __rhs); }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const _CharT* __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return !(__lhs == __rhs); }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return !(__lhs == __rhs); }
# 2414 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) < 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const _CharT* __rhs)
    { return __lhs.compare(__rhs) < 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const _CharT* __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) > 0; }
# 2451 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) > 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const _CharT* __rhs)
    { return __lhs.compare(__rhs) > 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const _CharT* __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) < 0; }
# 2488 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) <= 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return __lhs.compare(__rhs) <= 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const _CharT* __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) >= 0; }
# 2525 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) >= 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return __lhs.compare(__rhs) >= 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const _CharT* __lhs,
      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) <= 0; }
# 2562 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline void
    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
  basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { __lhs.swap(__rhs); }
# 2579 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is,
        basic_string<_CharT, _Traits, _Alloc>& __str);

  template<>
    basic_istream<char>&
    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
# 2597 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const basic_string<_CharT, _Traits, _Alloc>& __str)
    {


      return __ostream_insert(__os, __str.data(), __str.size());
    }
# 2620 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
# 2638 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str)
    { return getline(__is, __str, __is.widen('\n')); }

  template<>
    basic_istream<char>&
    getline(basic_istream<char>& __in, basic_string<char>& __str,
     char __delim);


  template<>
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
     wchar_t __delim);


}
# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.tcc" 1 3
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.tcc" 3
       
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.tcc" 3



namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;

  template<typename _CharT, typename _Traits, typename _Alloc>
    const _CharT
    basic_string<_CharT, _Traits, _Alloc>::
    _Rep::_S_terminal = _CharT();

  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::npos;



  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
    (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
      sizeof(size_type)];





  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIterator>
      _CharT*
      basic_string<_CharT, _Traits, _Alloc>::
      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
     input_iterator_tag)
      {

 if (__beg == __end && __a == _Alloc())
   return _S_empty_rep()._M_refdata();


 _CharT __buf[128];
 size_type __len = 0;
 while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
   {
     __buf[__len++] = *__beg;
     ++__beg;
   }
 _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
 _M_copy(__r->_M_refdata(), __buf, __len);
 try
   {
     while (__beg != __end)
       {
  if (__len == __r->_M_capacity)
    {

      _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
      _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
      __r->_M_destroy(__a);
      __r = __another;
    }
  __r->_M_refdata()[__len++] = *__beg;
  ++__beg;
       }
   }
 catch(...)
   {
     __r->_M_destroy(__a);
     throw;
   }
 __r->_M_set_length_and_sharable(__len);
 return __r->_M_refdata();
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template <typename _InIterator>
      _CharT*
      basic_string<_CharT, _Traits, _Alloc>::
      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
     forward_iterator_tag)
      {

 if (__beg == __end && __a == _Alloc())
   return _S_empty_rep()._M_refdata();


 if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
   __throw_logic_error(("basic_string::_S_construct NULL not valid"));

 const size_type __dnew = static_cast<size_type>(std::distance(__beg,
              __end));

 _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
 try
   { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
 catch(...)
   {
     __r->_M_destroy(__a);
     throw;
   }
 __r->_M_set_length_and_sharable(__dnew);
 return __r->_M_refdata();
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    _CharT*
    basic_string<_CharT, _Traits, _Alloc>::
    _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
    {

      if (__n == 0 && __a == _Alloc())
 return _S_empty_rep()._M_refdata();


      _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
      if (__n)
 _M_assign(__r->_M_refdata(), __n, __c);

      __r->_M_set_length_and_sharable(__n);
      return __r->_M_refdata();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str)
    : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
       __str.get_allocator()),
    __str.get_allocator())
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _Alloc& __a)
    : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str, size_type __pos, size_type __n)
    : _M_dataplus(_S_construct(__str._M_data()
          + __str._M_check(__pos,
      "basic_string::basic_string"),
          __str._M_data() + __str._M_limit(__pos, __n)
          + __pos, _Alloc()), _Alloc())
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str, size_type __pos,
   size_type __n, const _Alloc& __a)
    : _M_dataplus(_S_construct(__str._M_data()
          + __str._M_check(__pos,
      "basic_string::basic_string"),
          __str._M_data() + __str._M_limit(__pos, __n)
          + __pos, __a), __a)
    { }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
    : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
    { }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _CharT* __s, const _Alloc& __a)
    : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
          __s + npos, __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(size_type __n, _CharT __c, const _Alloc& __a)
    : _M_dataplus(_S_construct(__n, __c, __a), __a)
    { }


  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIterator>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
    : _M_dataplus(_S_construct(__beg, __end, __a), __a)
    { }
# 240 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.tcc" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    assign(const basic_string& __str)
    {
      if (_M_rep() != __str._M_rep())
 {

   const allocator_type __a = this->get_allocator();
   _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
   _M_rep()->_M_dispose(__a);
   _M_data(__tmp);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    assign(const _CharT* __s, size_type __n)
    {
      ;
      _M_check_length(this->size(), __n, "basic_string::assign");
      if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
 return _M_replace_safe(size_type(0), this->size(), __s, __n);
      else
 {

   const size_type __pos = __s - _M_data();
   if (__pos >= __n)
     _M_copy(_M_data(), __s, __n);
   else if (__pos)
     _M_move(_M_data(), __s, __n);
   _M_rep()->_M_set_length_and_sharable(__n);
   return *this;
 }
     }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(size_type __n, _CharT __c)
    {
      if (__n)
 {
   _M_check_length(size_type(0), __n, "basic_string::append");
   const size_type __len = __n + this->size();
   if (__len > this->capacity() || _M_rep()->_M_is_shared())
     this->reserve(__len);
   _M_assign(_M_data() + this->size(), __n, __c);
   _M_rep()->_M_set_length_and_sharable(__len);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(const _CharT* __s, size_type __n)
    {
      ;
      if (__n)
 {
   _M_check_length(size_type(0), __n, "basic_string::append");
   const size_type __len = __n + this->size();
   if (__len > this->capacity() || _M_rep()->_M_is_shared())
     {
       if (_M_disjunct(__s))
  this->reserve(__len);
       else
  {
    const size_type __off = __s - _M_data();
    this->reserve(__len);
    __s = _M_data() + __off;
  }
     }
   _M_copy(_M_data() + this->size(), __s, __n);
   _M_rep()->_M_set_length_and_sharable(__len);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(const basic_string& __str)
    {
      const size_type __size = __str.size();
      if (__size)
 {
   const size_type __len = __size + this->size();
   if (__len > this->capacity() || _M_rep()->_M_is_shared())
     this->reserve(__len);
   _M_copy(_M_data() + this->size(), __str._M_data(), __size);
   _M_rep()->_M_set_length_and_sharable(__len);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(const basic_string& __str, size_type __pos, size_type __n)
    {
      __str._M_check(__pos, "basic_string::append");
      __n = __str._M_limit(__pos, __n);
      if (__n)
 {
   const size_type __len = __n + this->size();
   if (__len > this->capacity() || _M_rep()->_M_is_shared())
     this->reserve(__len);
   _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
   _M_rep()->_M_set_length_and_sharable(__len);
 }
      return *this;
    }

   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>&
     basic_string<_CharT, _Traits, _Alloc>::
     insert(size_type __pos, const _CharT* __s, size_type __n)
     {
       ;
       _M_check(__pos, "basic_string::insert");
       _M_check_length(size_type(0), __n, "basic_string::insert");
       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
         return _M_replace_safe(__pos, size_type(0), __s, __n);
       else
         {

           const size_type __off = __s - _M_data();
           _M_mutate(__pos, 0, __n);
           __s = _M_data() + __off;
           _CharT* __p = _M_data() + __pos;
           if (__s + __n <= __p)
             _M_copy(__p, __s, __n);
           else if (__s >= __p)
             _M_copy(__p, __s + __n, __n);
           else
             {
        const size_type __nleft = __p - __s;
               _M_copy(__p, __s, __nleft);
               _M_copy(__p + __nleft, __p + __n, __n - __nleft);
             }
           return *this;
         }
     }

   template<typename _CharT, typename _Traits, typename _Alloc>
     typename basic_string<_CharT, _Traits, _Alloc>::iterator
     basic_string<_CharT, _Traits, _Alloc>::
     erase(iterator __first, iterator __last)
     {
      
                           ;




       const size_type __size = __last - __first;
       if (__size)
  {
    const size_type __pos = __first - _M_ibegin();
    _M_mutate(__pos, __size, size_type(0));
    _M_rep()->_M_set_leaked();
    return iterator(_M_data() + __pos);
  }
       else
  return __first;
     }

   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>&
     basic_string<_CharT, _Traits, _Alloc>::
     replace(size_type __pos, size_type __n1, const _CharT* __s,
      size_type __n2)
     {
       ;
       _M_check(__pos, "basic_string::replace");
       __n1 = _M_limit(__pos, __n1);
       _M_check_length(__n1, __n2, "basic_string::replace");
       bool __left;
       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
         return _M_replace_safe(__pos, __n1, __s, __n2);
       else if ((__left = __s + __n2 <= _M_data() + __pos)
  || _M_data() + __pos + __n1 <= __s)
  {

    size_type __off = __s - _M_data();
    __left ? __off : (__off += __n2 - __n1);
    _M_mutate(__pos, __n1, __n2);
    _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
    return *this;
  }
       else
  {

    const basic_string __tmp(__s, __n2);
    return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
  }
     }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _M_destroy(const _Alloc& __a) throw ()
    {
      const size_type __size = sizeof(_Rep_base) +
                        (this->_M_capacity + 1) * sizeof(_CharT);
      _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_leak_hard()
    {

      if (_M_rep() == &_S_empty_rep())
 return;

      if (_M_rep()->_M_is_shared())
 _M_mutate(0, 0, 0);
      _M_rep()->_M_set_leaked();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_mutate(size_type __pos, size_type __len1, size_type __len2)
    {
      const size_type __old_size = this->size();
      const size_type __new_size = __old_size + __len2 - __len1;
      const size_type __how_much = __old_size - __pos - __len1;

      if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
 {

   const allocator_type __a = get_allocator();
   _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);

   if (__pos)
     _M_copy(__r->_M_refdata(), _M_data(), __pos);
   if (__how_much)
     _M_copy(__r->_M_refdata() + __pos + __len2,
      _M_data() + __pos + __len1, __how_much);

   _M_rep()->_M_dispose(__a);
   _M_data(__r->_M_refdata());
 }
      else if (__how_much && __len1 != __len2)
 {

   _M_move(_M_data() + __pos + __len2,
    _M_data() + __pos + __len1, __how_much);
 }
      _M_rep()->_M_set_length_and_sharable(__new_size);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    reserve(size_type __res)
    {
      if (__res != this->capacity() || _M_rep()->_M_is_shared())
        {

   if (__res < this->size())
     __res = this->size();
   const allocator_type __a = get_allocator();
   _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
   _M_rep()->_M_dispose(__a);
   _M_data(__tmp);
        }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    swap(basic_string& __s)
    {
      if (_M_rep()->_M_is_leaked())
 _M_rep()->_M_set_sharable();
      if (__s._M_rep()->_M_is_leaked())
 __s._M_rep()->_M_set_sharable();
      if (this->get_allocator() == __s.get_allocator())
 {
   _CharT* __tmp = _M_data();
   _M_data(__s._M_data());
   __s._M_data(__tmp);
 }

      else
 {
   const basic_string __tmp1(_M_ibegin(), _M_iend(),
        __s.get_allocator());
   const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
        this->get_allocator());
   *this = __tmp2;
   __s = __tmp1;
 }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _S_create(size_type __capacity, size_type __old_capacity,
       const _Alloc& __alloc)
    {


      if (__capacity > _S_max_size)
 __throw_length_error(("basic_string::_S_create"));
# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.tcc" 3
      const size_type __pagesize = 4096;
      const size_type __malloc_header_size = 4 * sizeof(void*);







      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
 __capacity = 2 * __old_capacity;




      size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);

      const size_type __adj_size = __size + __malloc_header_size;
      if (__adj_size > __pagesize && __capacity > __old_capacity)
 {
   const size_type __extra = __pagesize - __adj_size % __pagesize;
   __capacity += __extra / sizeof(_CharT);

   if (__capacity > _S_max_size)
     __capacity = _S_max_size;
   __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
 }



      void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
      _Rep *__p = new (__place) _Rep;
      __p->_M_capacity = __capacity;







      __p->_M_set_sharable();
      return __p;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    _CharT*
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _M_clone(const _Alloc& __alloc, size_type __res)
    {

      const size_type __requested_cap = this->_M_length + __res;
      _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
      __alloc);
      if (this->_M_length)
 _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);

      __r->_M_set_length_and_sharable(this->_M_length);
      return __r->_M_refdata();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    resize(size_type __n, _CharT __c)
    {
      const size_type __size = this->size();
      _M_check_length(__size, __n, "basic_string::resize");
      if (__size < __n)
 this->append(__n - __size, __c);
      else if (__n < __size)
 this->erase(__n);

    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIterator>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
     _InputIterator __k2, __false_type)
      {
 const basic_string __s(__k1, __k2);
 const size_type __n1 = __i2 - __i1;
 _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
 return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
          __s.size());
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
     _CharT __c)
    {
      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
      _M_mutate(__pos1, __n1, __n2);
      if (__n2)
 _M_assign(_M_data() + __pos1, __n2, __c);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
      size_type __n2)
    {
      _M_mutate(__pos1, __n1, __n2);
      if (__n2)
 _M_copy(_M_data() + __pos1, __s, __n2);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(const _CharT* __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      ;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      const __size_type __len = _Traits::length(__lhs);
      __string_type __str;
      __str.reserve(__len + __rhs.size());
      __str.append(__lhs, __len);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __string_type __str;
      const __size_type __len = __rhs.size();
      __str.reserve(__len + 1);
      __str.append(__size_type(1), __lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    copy(_CharT* __s, size_type __n, size_type __pos) const
    {
      _M_check(__pos, "basic_string::copy");
      __n = _M_limit(__pos, __n);
      ;
      if (__n)
 _M_copy(__s, _M_data() + __pos, __n);

      return __n;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      const size_type __size = this->size();
      const _CharT* __data = _M_data();

      if (__n == 0)
 return __pos <= __size ? __pos : npos;

      if (__n <= __size)
 {
   for (; __pos <= __size - __n; ++__pos)
     if (traits_type::eq(__data[__pos], __s[0])
  && traits_type::compare(__data + __pos + 1,
     __s + 1, __n - 1) == 0)
       return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(_CharT __c, size_type __pos) const
    {
      size_type __ret = npos;
      const size_type __size = this->size();
      if (__pos < __size)
 {
   const _CharT* __data = _M_data();
   const size_type __n = __size - __pos;
   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
   if (__p)
     __ret = __p - __data;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      const size_type __size = this->size();
      if (__n <= __size)
 {
   __pos = std::min(size_type(__size - __n), __pos);
   const _CharT* __data = _M_data();
   do
     {
       if (traits_type::compare(__data + __pos, __s, __n) == 0)
  return __pos;
     }
   while (__pos-- > 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(_CharT __c, size_type __pos) const
    {
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   for (++__size; __size-- > 0; )
     if (traits_type::eq(_M_data()[__size], __c))
       return __size;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      for (; __n && __pos < this->size(); ++__pos)
 {
   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
   if (__p)
     return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      size_type __size = this->size();
      if (__size && __n)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (traits_type::find(__s, __n, _M_data()[__size]))
  return __size;
     }
   while (__size-- != 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::find(__s, __n, _M_data()[__pos]))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(_CharT __c, size_type __pos) const
    {
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::eq(_M_data()[__pos], __c))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::find(__s, __n, _M_data()[__size]))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(_CharT __c, size_type __pos) const
    {
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::eq(_M_data()[__size], __c))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n, const basic_string& __str) const
    {
      _M_check(__pos, "basic_string::compare");
      __n = _M_limit(__pos, __n);
      const size_type __osize = __str.size();
      const size_type __len = std::min(__n, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
      if (!__r)
 __r = _S_compare(__n, __osize);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(size_type __pos1, size_type __n1, const basic_string& __str,
     size_type __pos2, size_type __n2) const
    {
      _M_check(__pos1, "basic_string::compare");
      __str._M_check(__pos2, "basic_string::compare");
      __n1 = _M_limit(__pos1, __n1);
      __n2 = __str._M_limit(__pos2, __n2);
      const size_type __len = std::min(__n1, __n2);
      int __r = traits_type::compare(_M_data() + __pos1,
         __str.data() + __pos2, __len);
      if (!__r)
 __r = _S_compare(__n1, __n2);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(const _CharT* __s) const
    {
      ;
      const size_type __size = this->size();
      const size_type __osize = traits_type::length(__s);
      const size_type __len = std::min(__size, __osize);
      int __r = traits_type::compare(_M_data(), __s, __len);
      if (!__r)
 __r = _S_compare(__size, __osize);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string <_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n1, const _CharT* __s) const
    {
      ;
      _M_check(__pos, "basic_string::compare");
      __n1 = _M_limit(__pos, __n1);
      const size_type __osize = traits_type::length(__s);
      const size_type __len = std::min(__n1, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
 __r = _S_compare(__n1, __osize);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string <_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n1, const _CharT* __s,
     size_type __n2) const
    {
      ;
      _M_check(__pos, "basic_string::compare");
      __n1 = _M_limit(__pos, __n1);
      const size_type __len = std::min(__n1, __n2);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
 __r = _S_compare(__n1, __n2);
      return __r;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in,
        basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __istream_type::ios_base __ios_base;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __string_type::size_type __size_type;
      typedef ctype<_CharT> __ctype_type;
      typedef typename __ctype_type::ctype_base __ctype_base;

      __size_type __extracted = 0;
      typename __ios_base::iostate __err = __ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       __str.erase();
       _CharT __buf[128];
       __size_type __len = 0;
       const streamsize __w = __in.width();
       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
                                : __str.max_size();
       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
       const __int_type __eof = _Traits::eof();
       __int_type __c = __in.rdbuf()->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(__ctype_base::space,
     _Traits::to_char_type(__c)))
  {
    if (__len == sizeof(__buf) / sizeof(_CharT))
      {
        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
        __len = 0;
      }
    __buf[__len++] = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __in.rdbuf()->snextc();
  }
       __str.append(__buf, __len);

       if (_Traits::eq_int_type(__c, __eof))
  __err |= __ios_base::eofbit;
       __in.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     {



       __in._M_setstate(__ios_base::badbit);
     }
 }

      if (!__extracted)
 __err |= __ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __istream_type::ios_base __ios_base;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      const __size_type __n = __str.max_size();
      typename __ios_base::iostate __err = __ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, true);
      if (__cerb)
 {
   try
     {
       __str.erase();
       const __int_type __idelim = _Traits::to_int_type(__delim);
       const __int_type __eof = _Traits::eof();
       __int_type __c = __in.rdbuf()->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !_Traits::eq_int_type(__c, __idelim))
  {
    __str += _Traits::to_char_type(__c);
    ++__extracted;
    __c = __in.rdbuf()->snextc();
  }

       if (_Traits::eq_int_type(__c, __eof))
  __err |= __ios_base::eofbit;
       else if (_Traits::eq_int_type(__c, __idelim))
  {
    ++__extracted;
    __in.rdbuf()->sbumpc();
  }
       else
  __err |= __ios_base::failbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     {



       __in._M_setstate(__ios_base::badbit);
     }
 }
      if (!__extracted)
 __err |= __ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }





  extern template class basic_string<char>;
  extern template
    basic_istream<char>&
    operator>>(basic_istream<char>&, string&);
  extern template
    basic_ostream<char>&
    operator<<(basic_ostream<char>&, const string&);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&, char);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&);


  extern template class basic_string<wchar_t>;
  extern template
    basic_istream<wchar_t>&
    operator>>(basic_istream<wchar_t>&, wstring&);
  extern template
    basic_ostream<wchar_t>&
    operator<<(basic_ostream<wchar_t>&, const wstring&);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&);



}
# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
# 61 "/usr/include/qt4/QtCore/qstring.h" 2




typedef std::basic_string<wchar_t> QStdWString;
# 76 "/usr/include/qt4/QtCore/qstring.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

class QCharRef;
class QRegExp;
class QStringList;
class QTextCodec;
class QLatin1String;
class QStringRef;
template <typename T> class QVector;

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 || d->ref != 1) realloc(); d->capacity = 0;}

    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 __attribute__ ((warn_unused_result));
    QString arg(qulonglong a, int fieldwidth=0, int base=10,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(long a, int fieldwidth=0, int base=10,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(ulong a, int fieldwidth=0, int base=10,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(int a, int fieldWidth = 0, int base = 10,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(uint a, int fieldWidth = 0, int base = 10,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(short a, int fieldWidth = 0, int base = 10,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(ushort a, int fieldWidth = 0, int base = 10,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(char a, int fieldWidth = 0,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(QChar a, int fieldWidth = 0,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(const QString &a, int fieldWidth = 0,
                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
    QString arg(const QString &a1, const QString &a2) const __attribute__ ((warn_unused_result));
    QString arg(const QString &a1, const QString &a2, const QString &a3) const __attribute__ ((warn_unused_result));
    QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4) const __attribute__ ((warn_unused_result));
    QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4, const QString &a5) const __attribute__ ((warn_unused_result));
    QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4, const QString &a5, const QString &a6) const __attribute__ ((warn_unused_result));
    QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4, const QString &a5, const QString &a6,
                const QString &a7) const __attribute__ ((warn_unused_result));
    QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4, const QString &a5, const QString &a6,
                const QString &a7, const QString &a8) const __attribute__ ((warn_unused_result));
    QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4, const QString &a5, const QString &a6,
                const QString &a7, const QString &a8, const QString &a9) const __attribute__ ((warn_unused_result));

    QString &vsprintf(const char *format, va_list ap)

        __attribute__ ((format (printf, 2, 0)))

        ;
    QString &sprintf(const char *format, ...)

        __attribute__ ((format (printf, 2, 3)))

        ;

    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 indexOf(const QLatin1String &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;
    int lastIndexOf(const QLatin1String &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;

    int indexOf(QRegExp &, int from = 0) const;
    int lastIndexOf(QRegExp &, int from = -1) const;
    inline QBool contains(QRegExp &rx) const { return QBool(indexOf(rx) != -1); }


    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 n) const __attribute__ ((warn_unused_result));
    QString right(int n) const __attribute__ ((warn_unused_result));
    QString mid(int position, int n = -1) const __attribute__ ((warn_unused_result));
    QStringRef leftRef(int n) const __attribute__ ((warn_unused_result));
    QStringRef rightRef(int n) const __attribute__ ((warn_unused_result));
    QStringRef midRef(int position, int n = -1) const __attribute__ ((warn_unused_result));

    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 __attribute__ ((warn_unused_result));
    QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const __attribute__ ((warn_unused_result));

    QString toLower() const __attribute__ ((warn_unused_result));
    QString toUpper() const __attribute__ ((warn_unused_result));
    QString toCaseFolded() const __attribute__ ((warn_unused_result));

    QString trimmed() const __attribute__ ((warn_unused_result));
    QString simplified() const __attribute__ ((warn_unused_result));

    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 QStringRef &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) {
        if (d->ref != 1 || d->size + 1 > d->alloc)
            realloc(grow(d->size + 1));
        d->data[d->size++] = c.unicode();
        d->data[d->size] = '\0';
        return *this;
    }

    inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); }
    inline QString &operator+=(const QString &s) { return append(s); }
    inline QString &operator+=(const QStringRef &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(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(const QString &before, const QString &after,
                     Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(QChar c, const QLatin1String &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 __attribute__ ((warn_unused_result));
    QStringList split(const QChar &sep, SplitBehavior behavior = KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((warn_unused_result));

    QStringList split(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const __attribute__ ((warn_unused_result));


    enum NormalizationForm {
        NormalizationForm_D,
        NormalizationForm_C,
        NormalizationForm_KD,
        NormalizationForm_KC
    };
    QString normalized(NormalizationForm mode) const __attribute__ ((warn_unused_result));
    QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const __attribute__ ((warn_unused_result));

    QString repeated(int times) const;

    const ushort *utf16() const;

    QByteArray toAscii() const __attribute__ ((warn_unused_result));
    QByteArray toLatin1() const __attribute__ ((warn_unused_result));
    QByteArray toUtf8() const __attribute__ ((warn_unused_result));
    QByteArray toLocal8Bit() const __attribute__ ((warn_unused_result));
    QVector<uint> toUcs4() const __attribute__ ((warn_unused_result));

    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 fromUcs4(const uint *, int size = -1);
    static QString fromRawData(const QChar *, int size);

    int toWCharArray(wchar_t *array) const;
    static QString fromWCharArray(const wchar_t *, int size = -1);

    QString &setUnicode(const QChar *unicode, int size);
    inline QString &setUtf16(const ushort *utf16, int size);


    int compare(const QString &s) const;
    int compare(const QString &s, Qt::CaseSensitivity cs) const;

    int compare(const QLatin1String &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;


    static inline int compare(const QString &s1, const QString &s2)
    { return s1.compare(s2); }
    static inline int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs)
    { return s1.compare(s2, cs); }

    static inline int compare(const QString& s1, const QLatin1String &s2,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive)
    { return s1.compare(s2, cs); }
    static inline int compare(const QLatin1String& s1, const QString &s2,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive)
    { return -s2.compare(s1, cs); }

    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    static int compare(const QString &s1, const QStringRef &s2,
                       Qt::CaseSensitivity = Qt::CaseSensitive);

    int localeAwareCompare(const QString& s) const;
    static int localeAwareCompare(const QString& s1, const QString& s2)
    { return s1.localeAwareCompare(s2); }

    int localeAwareCompare(const QStringRef &s) const;
    static int localeAwareCompare(const QString& s1, const QStringRef& 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(fromAscii_helper(ch))
    {}
    inline QString(const QByteArray &a)
        : d(fromAscii_helper(a.constData(), qstrnlen(a.constData(), a.size())))
    {}
    inline QString &operator=(const char *ch)
    { return (*this = fromAscii(ch)); }
    inline QString &operator=(const QByteArray &a)
    { return (*this = fromAscii(a.constData(), qstrnlen(a.constData(), a.size()))); }
    inline QString &operator=(char c)
    { return (*this = QChar::fromAscii(c)); }


    inline QString &prepend(const char *s)
    { return prepend(QString::fromAscii(s)); }
    inline QString &prepend(const QByteArray &s)
    { return prepend(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
    inline QString &append(const char *s)
    { return append(QString::fromAscii(s)); }
    inline QString &append(const QByteArray &s)
    { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
    inline QString &operator+=(const char *s)
    { return append(QString::fromAscii(s)); }
    inline QString &operator+=(const QByteArray &s)
    { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
    inline QString &operator+=(char c)
    { return append(QChar::fromAscii(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;
    inline bool operator!=(const QByteArray &s) const;
    inline bool operator<(const QByteArray &s) const
    { return *this < QString::fromAscii(s.constData(), s.size()); }
    inline bool operator>(const QByteArray &s) const
    { return *this > QString::fromAscii(s.constData(), s.size()); }
    inline bool operator<=(const QByteArray &s) const
    { return *this <= QString::fromAscii(s.constData(), s.size()); }
    inline bool operator>=(const QByteArray &s) const
    { return *this >= QString::fromAscii(s.constData(), s.size()); }


    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; }
# 579 "/usr/include/qt4/QtCore/qstring.h"
    bool isSimpleText() const { if (!d->clean) updateProperties(); return d->simpletext; }
    bool isRightToLeft() const { if (!d->clean) updateProperties(); return d->righttoleft; }

    QString(int size, Qt::Initialization);

private:
# 594 "/usr/include/qt4/QtCore/qstring.h"
    struct Data {
        QBasicAtomicInt ref;
        int alloc, size;
        ushort *data;
        ushort clean : 1;
        ushort simpletext : 1;
        ushort righttoleft : 1;
        ushort asciiCache : 1;
        ushort capacity : 1;
        ushort reserved : 11;
        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;
    static int compare_helper(const QChar *data1, int length1,
                              const QChar *data2, int length2,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive);
    static int compare_helper(const QChar *data1, int length1,
                              QLatin1String s2,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive);
    static int localeAwareCompare_helper(const QChar *data1, int length1,
                                         const QChar *data2, int length2);
    static Data *fromLatin1_helper(const char *str, int size = -1);
    static Data *fromAscii_helper(const char *str, int size = -1);
    void replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen);
    friend class QCharRef;
    friend class QTextCodec;
    friend class QStringRef;
    friend struct QAbstractConcatenable;
    friend inline bool qStringComparisonHelper(const QString &s1, const char *s2);
    friend inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2);
public:
    typedef Data * DataPtr;
    inline DataPtr &data_ptr() { return d; }
};


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; }

    inline bool operator==(const char *s) const
        { return QString::fromAscii(s) == *this; }
    inline bool operator!=(const char *s) const
        { return QString::fromAscii(s) != *this; }
    inline bool operator<(const char *s) const
        { return QString::fromAscii(s) > *this; }
    inline bool operator>(const char *s) const
        { return QString::fromAscii(s) < *this; }
    inline bool operator<=(const char *s) const
        { return QString::fromAscii(s) >= *this; }
    inline bool operator>=(const char *s) const
        { return QString::fromAscii(s) <= *this; }
private:
    const char *chars;
};



inline QString::QString(const QLatin1String &aLatin1) : d(fromLatin1_helper(aLatin1.latin1()))
{ }
inline int QString::length() const
{ return d->size; }
inline const QChar QString::at(int i) const
{ ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","/usr/include/qt4/QtCore/qstring.h",688) : qt_noop()); return d->data[i]; }
inline const QChar QString::operator[](int i) const
{ ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","/usr/include/qt4/QtCore/qstring.h",690) : qt_noop()); return d->data[i]; }
inline const QChar QString::operator[](uint i) const
{ ((!(i < uint(size()))) ? qt_assert("i < uint(size())","/usr/include/qt4/QtCore/qstring.h",692) : qt_noop()); 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 &other) : d(other.d)
{ ((!(&other != this)) ? qt_assert("&other != this","/usr/include/qt4/QtCore/qstring.h",715) : qt_noop()); 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::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4, const QString &a5) const
{ const QString *args[5] = { &a1, &a2, &a3, &a4, &a5 }; return multiArg(5, args); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4, const QString &a5, const QString &a6) const
{ const QString *args[6] = { &a1, &a2, &a3, &a4, &a5, &a6 }; return multiArg(6, args); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4, const QString &a5, const QString &a6,
                            const QString &a7) const
{ const QString *args[7] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7 }; return multiArg(7, args); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4, const QString &a5, const QString &a6,
                            const QString &a7, const QString &a8) const
{ const QString *args[8] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8 }; return multiArg(8, args); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4, const QString &a5, const QString &a6,
                            const QString &a7, const QString &a8, const QString &a9) const
{ const QString *args[9] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9 }; return multiArg(9, 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 (i >= s.d->size) s.expand(i); else s.detach();
          s.d->data[i] = c.unicode(); return *this; }



    inline QCharRef &operator=(char c)
    { return operator=(QChar::fromAscii(c)); }
    inline QCharRef &operator=(uchar c)
    { return operator=(QChar::fromAscii(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 bool isLower() const { return QChar(*this).isLower(); }
    inline bool isUpper() const { return QChar(*this).isUpper(); }
    inline bool isTitleCase() const { return QChar(*this).isTitleCase(); }

    inline int digitValue() const { return QChar(*this).digitValue(); }
    QChar toLower() const { return QChar(*this).toLower(); }
    QChar toUpper() const { return QChar(*this).toUpper(); }
    QChar toTitleCase () const { return QChar(*this).toTitleCase(); }

    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(); }
    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);






    char toAscii() const { return QChar(*this).toAscii(); }
    char toLatin1() const { return QChar(*this).toLatin1(); }
    ushort unicode() const { return QChar(*this).unicode(); }

    ushort& unicode() { return s.data()[i].unicode(); }
# 862 "/usr/include/qt4/QtCore/qstring.h"
};

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); d->capacity = 1;}
inline QString &QString::setUtf16(const ushort *autf16, int asize)
{ return setUnicode(reinterpret_cast<const QChar *>(autf16), asize); }
inline QCharRef QString::operator[](int i)
{ ((!(i >= 0)) ? qt_assert("i >= 0","/usr/include/qt4/QtCore/qstring.h",874) : qt_noop()); 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 qStringComparisonHelper(const QString &s1, const char *s2)
{

    if (QString::codecForCStrings) return (s1 == QString::fromAscii(s2));

    return (s1 == QLatin1String(s2));
}
inline bool QString::operator==(const char *s) const
{ return qStringComparisonHelper(*this, s); }
inline bool QString::operator!=(const char *s) const
{ return !qStringComparisonHelper(*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 qStringComparisonHelper(s2, s1); }
inline bool operator!=(const char *s1, const QString &s2)
{ return !qStringComparisonHelper(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 operator==(const char *s1, const QLatin1String &s2)
{ return QString::fromAscii(s1) == s2; }
inline bool operator!=(const char *s1, const QLatin1String &s2)
{ return QString::fromAscii(s1) != s2; }
inline bool operator<(const char *s1, const QLatin1String &s2)
{ return (QString::fromAscii(s1) < s2); }
inline bool operator>(const char *s1, const QLatin1String &s2)
{ return (QString::fromAscii(s1) > s2); }
inline bool operator<=(const char *s1, const QLatin1String &s2)
{ return (QString::fromAscii(s1) <= s2); }
inline bool operator>=(const char *s1, const QLatin1String &s2)
{ return (QString::fromAscii(s1) >= s2); }

inline bool operator==(const QLatin1String &s1, const QLatin1String &s2)
{ return (qstrcmp(s1.latin1(), s2.latin1()) == 0); }
inline bool operator!=(const QLatin1String &s1, const QLatin1String &s2)
{ return (qstrcmp(s1.latin1(), s2.latin1()) != 0); }
inline bool operator<(const QLatin1String &s1, const QLatin1String &s2)
{ return (qstrcmp(s1.latin1(), s2.latin1()) < 0); }
inline bool operator<=(const QLatin1String &s1, const QLatin1String &s2)
{ return (qstrcmp(s1.latin1(), s2.latin1()) <= 0); }
inline bool operator>(const QLatin1String &s1, const QLatin1String &s2)
{ return (qstrcmp(s1.latin1(), s2.latin1()) > 0); }
inline bool operator>=(const QLatin1String &s1, const QLatin1String &s2)
{ return (qstrcmp(s1.latin1(), s2.latin1()) >= 0); }


inline bool QString::operator==(const QByteArray &s) const
{ return qStringComparisonHelper(*this, s.constData()); }
inline bool QString::operator!=(const QByteArray &s) const
{ return !qStringComparisonHelper(*this, s.constData()); }

inline bool QByteArray::operator==(const QString &s) const
{ return qStringComparisonHelper(s, constData()); }
inline bool QByteArray::operator!=(const QString &s) const
{ return !qStringComparisonHelper(s, constData()); }
inline bool QByteArray::operator<(const QString &s) const
{ return QString::fromAscii(constData(), size()) < s; }
inline bool QByteArray::operator>(const QString &s) const
{ return QString::fromAscii(constData(), size()) > s; }
inline bool QByteArray::operator<=(const QString &s) const
{ return QString::fromAscii(constData(), size()) <= s; }
inline bool QByteArray::operator>=(const QString &s) const
{ return QString::fromAscii(constData(), size()) >= s; }



inline QByteArray &QByteArray::append(const QString &s)
{ return append(s.toAscii()); }
inline QByteArray &QByteArray::insert(int i, const QString &s)
{ return insert(i, s.toAscii()); }
inline QByteArray &QByteArray::replace(char c, const QString &after)
{ return replace(c, after.toAscii()); }
inline QByteArray &QByteArray::replace(const QString &before, const char *after)
{ return replace(before.toAscii(), after); }
inline QByteArray &QByteArray::replace(const QString &before, const QByteArray &after)
{ return replace(before.toAscii(), after); }
inline QByteArray &QByteArray::operator+=(const QString &s)
{ return operator+=(s.toAscii()); }
inline int QByteArray::indexOf(const QString &s, int from) const
{ return indexOf(s.toAscii(), from); }
inline int QByteArray::lastIndexOf(const QString &s, int from) const
{ return lastIndexOf(s.toAscii(), from); }
# 1009 "/usr/include/qt4/QtCore/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 = QString::fromAscii(s1); t += s2; return t; }
inline const QString operator+(char c, const QString &s)
{ QString t = s; t.prepend(QChar::fromAscii(c)); return t; }
inline const QString operator+(const QString &s, char c)
{ QString t = s; t += QChar::fromAscii(c); return t; }
inline const QString operator+(const QByteArray &ba, const QString &s)
{ QString t = QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); t += s; return t; }
inline const QString operator+(const QString &s, const QByteArray &ba)
{ QString t(s); t += QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); 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())); }
# 1069 "/usr/include/qt4/QtCore/qstring.h"
 QDataStream &operator<<(QDataStream &, const QString &);
 QDataStream &operator>>(QDataStream &, QString &);
# 1083 "/usr/include/qt4/QtCore/qstring.h"
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(); } template <> inline void qSwap<QString>(QString &value1, QString &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
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; } inline QIncompatibleFlag operator|(QString::SectionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
# 1094 "/usr/include/qt4/QtCore/qstring.h"
class QStringRef {
    const QString *m_string;
    int m_position;
    int m_size;
public:
    inline QStringRef():m_string(0), m_position(0), m_size(0){}
    inline QStringRef(const QString *string, int position, int size);
    inline QStringRef(const QString *string);
    inline QStringRef(const QStringRef &other)
        :m_string(other.m_string), m_position(other.m_position), m_size(other.m_size)
        {}

    inline ~QStringRef(){}
    inline const QString *string() const { return m_string; }
    inline int position() const { return m_position; }
    inline int size() const { return m_size; }
    inline int count() const { return m_size; }
    inline int length() const { return m_size; }

    inline QStringRef &operator=(const QStringRef &other) {
        m_string = other.m_string; m_position = other.m_position;
        m_size = other.m_size; return *this;
    }

    inline QStringRef &operator=(const QString *string);

    inline const QChar *unicode() const {
        if (!m_string)
            return reinterpret_cast<const QChar *>(QString::shared_null.data);
        return m_string->unicode() + m_position;
    }
    inline const QChar *data() const { return unicode(); }
    inline const QChar *constData() const { return unicode(); }

    inline void clear() { m_string = 0; m_position = m_size = 0; }
    QString toString() const;
    inline bool isEmpty() const { return m_size == 0; }
    inline bool isNull() const { return m_string == 0 || m_string->isNull(); }

    QStringRef appendTo(QString *string) const;

    inline const QChar at(int i) const
        { ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","/usr/include/qt4/QtCore/qstring.h",1136) : qt_noop()); return m_string->at(i + m_position); }

    int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int compare(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    static int compare(const QStringRef &s1, const QString &s2,
                       Qt::CaseSensitivity = Qt::CaseSensitive);
    static int compare(const QStringRef &s1, const QStringRef &s2,
                       Qt::CaseSensitivity = Qt::CaseSensitive);
    static int compare(const QStringRef &s1, QLatin1String s2,
                       Qt::CaseSensitivity cs = Qt::CaseSensitive);

    int localeAwareCompare(const QString &s) const;
    int localeAwareCompare(const QStringRef &s) const;
    static int localeAwareCompare(const QStringRef &s1, const QString &s2);
    static int localeAwareCompare(const QStringRef &s1, const QStringRef &s2);
};

inline QStringRef &QStringRef::operator=(const QString *aString)
{ m_string = aString; m_position = 0; m_size = aString?aString->size():0; return *this; }

inline QStringRef::QStringRef(const QString *aString, int aPosition, int aSize)
        :m_string(aString), m_position(aPosition), m_size(aSize){}

inline QStringRef::QStringRef(const QString *aString)
    :m_string(aString), m_position(0), m_size(aString?aString->size() : 0){}

 bool operator==(const QStringRef &s1,const QStringRef &s2);
inline bool operator!=(const QStringRef &s1,const QStringRef &s2)
{ return !(s1 == s2); }
 bool operator==(const QString &s1,const QStringRef &s2);
inline bool operator!=(const QString &s1,const QStringRef &s2)
{ return !(s1 == s2); }
inline bool operator==(const QStringRef &s1,const QString &s2)
{ return s2 == s1; }
inline bool operator!=(const QStringRef &s1,const QString &s2)
{ return s2 != s1; }
 bool operator==(const QLatin1String &s1, const QStringRef &s2);
inline bool operator!=(const QLatin1String &s1,const QStringRef &s2)
{ return !(s1 == s2); }
inline bool operator==(const QStringRef &s1,const QLatin1String &s2)
{ return s2 == s1; }
inline bool operator!=(const QStringRef &s1,const QLatin1String &s2)
{ return s2 != s1; }

 bool operator<(const QStringRef &s1,const QStringRef &s2);
inline bool operator>(const QStringRef &s1, const QStringRef &s2)
{ return s2 < s1; }
inline bool operator<=(const QStringRef &s1, const QStringRef &s2)
{ return !(s1 > s2); }
inline bool operator>=(const QStringRef &s1, const QStringRef &s2)
{ return !(s1 < s2); }

inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2)
{

    if (QString::codecForCStrings) return (s1 == QString::fromAscii(s2));

    return (s1 == QLatin1String(s2));
}

inline bool operator==(const char *s1, const QStringRef &s2)
{ return qStringComparisonHelper(s2, s1); }
inline bool operator==(const QStringRef &s1, const char *s2)
{ return qStringComparisonHelper(s1, s2); }
inline bool operator!=(const char *s1, const QStringRef &s2)
{ return !qStringComparisonHelper(s2, s1); }
inline bool operator!=(const QStringRef &s1, const char *s2)
{ return !qStringComparisonHelper(s1, s2); }

inline int QString::compare(const QStringRef &s, Qt::CaseSensitivity cs) const
{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
inline int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs)
{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const
{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const
{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const
{ return QString::compare_helper(constData(), length(), s, cs); }
inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs)
{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
inline int QStringRef::compare(const QStringRef &s1, const QStringRef &s2, Qt::CaseSensitivity cs)
{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
inline int QStringRef::compare(const QStringRef &s1, QLatin1String s2, Qt::CaseSensitivity cs)
{ return QString::compare_helper(s1.constData(), s1.length(), s2, cs); }

inline int QString::localeAwareCompare(const QStringRef &s) const
{ return localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
inline int QString::localeAwareCompare(const QString& s1, const QStringRef& s2)
{ return localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
inline int QStringRef::localeAwareCompare(const QString &s) const
{ return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
inline int QStringRef::localeAwareCompare(const QStringRef &s) const
{ return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QString &s2)
{ return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QStringRef &s2)
{ return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }





# 26 "/usr/include/qt4/QtWebKit/qwebsettings.h" 2
# 1 "/usr/include/qt4/QtGui/qpixmap.h" 1
# 45 "/usr/include/qt4/QtGui/qpixmap.h"
# 1 "/usr/include/qt4/QtGui/qpaintdevice.h" 1
# 45 "/usr/include/qt4/QtGui/qpaintdevice.h"
# 1 "/usr/include/qt4/QtGui/qwindowdefs.h" 1
# 45 "/usr/include/qt4/QtGui/qwindowdefs.h"
# 1 "/usr/include/qt4/QtCore/qobjectdefs.h" 1
# 47 "/usr/include/qt4/QtCore/qobjectdefs.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

class QByteArray;

class QString;
# 141 "/usr/include/qt4/QtCore/qobjectdefs.h"
template <typename T>
inline int qYouForgotTheQ_OBJECT_Macro(T, T) { return 0; }

template <typename T1, typename T2>
inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {}
# 210 "/usr/include/qt4/QtCore/qobjectdefs.h"
 const char *qFlagLocation(const char *method);
# 238 "/usr/include/qt4/QtCore/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 <typename 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;
    QString tr(const char *s, const char *c, int n) const;
    QString trUtf8(const char *s, const char *c, int n) const;


    int methodOffset() const;
    int enumeratorOffset() const;
    int propertyOffset() const;
    int classInfoOffset() const;

    int constructorCount() const;
    int methodCount() const;
    int enumeratorCount() const;
    int propertyCount() const;
    int classInfoCount() const;

    int indexOfConstructor(const char *constructor) 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 constructor(int index) const;
    QMetaMethod method(int index) const;
    QMetaEnum enumerator(int index) const;
    QMetaProperty property(int index) const;
    QMetaClassInfo classInfo(int index) const;
    QMetaProperty userProperty() const;

    static bool checkConnectArgs(const char *signal, const char *method);
    static QByteArray normalizedSignature(const char *method);
    static QByteArray normalizedType(const char *type);


    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 bool disconnectOne(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);
    }

    QObject *newInstance(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()) const;

    enum Call {
        InvokeMetaMethod,
        ReadProperty,
        WriteProperty,
        ResetProperty,
        QueryPropertyDesignable,
        QueryPropertyScriptable,
        QueryPropertyStored,
        QueryPropertyEditable,
        QueryPropertyUser,
        CreateInstance
    };

    int static_metacall(Call, int, void **) const;
    static int metacall(QObject *, Call, int, void **);





    struct {
        const QMetaObject *superdata;
        const char *stringdata;
        const uint *data;
        const void *extradata;
    } d;

};

typedef const QMetaObject& (*QMetaObjectAccessor)();

struct QMetaObjectExtraData
{



    const QMetaObject **objects;

    int (*static_metacall)(QMetaObject::Call, int, void **);
};

inline const char *QMetaObject::className() const
{ return d.stringdata; }

inline const QMetaObject *QMetaObject::superClass() const
{ return d.superdata; }









# 46 "/usr/include/qt4/QtGui/qwindowdefs.h" 2





typedef QtValidLicenseForGuiModule QtGuiModule;



class QPaintDevice;
class QWidget;
class QDialog;
class QColor;
class QPalette;



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;



# 115 "/usr/include/qt4/QtGui/qwindowdefs.h"
typedef struct _XDisplay Display;
typedef union _XEvent XEvent;
typedef struct _XGC *GC;
typedef struct _XRegion *Region;
typedef unsigned long WId;
# 139 "/usr/include/qt4/QtGui/qwindowdefs.h"



template<class K, class V> class QHash;
typedef QHash<WId, QWidget *> QWidgetMapper;

template<class V> class QSet;
typedef QSet<QWidget *> QWidgetSet;



# 46 "/usr/include/qt4/QtGui/qpaintdevice.h" 2
# 1 "/usr/include/qt4/QtCore/qrect.h" 1
# 45 "/usr/include/qt4/QtCore/qrect.h"
# 1 "/usr/include/qt4/QtCore/qsize.h" 1
# 47 "/usr/include/qt4/QtCore/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)
{
    ((!(!qFuzzyIsNull(c))) ? qt_assert("!qFuzzyIsNull(c)","/usr/include/qt4/QtCore/qsize.h",176) : qt_noop());
    wd = qRound(wd/c); ht = qRound(ht/c);
    return *this;
}

inline const QSize operator/(const QSize &s, qreal c)
{
    ((!(!qFuzzyIsNull(c))) ? qt_assert("!qFuzzyIsNull(c)","/usr/include/qt4/QtCore/qsize.h",183) : qt_noop());
    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)
{
    ((!(!qFuzzyIsNull(c))) ? qt_assert("!qFuzzyIsNull(c)","/usr/include/qt4/QtCore/qsize.h",334) : qt_noop());
    wd = wd/c; ht = ht/c;
    return *this;
}

inline const QSizeF operator/(const QSizeF &s, qreal c)
{
    ((!(!qFuzzyIsNull(c))) ? qt_assert("!qFuzzyIsNull(c)","/usr/include/qt4/QtCore/qsize.h",341) : qt_noop());
    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 &);





# 46 "/usr/include/qt4/QtCore/qrect.h" 2
# 1 "/usr/include/qt4/QtCore/qpoint.h" 1
# 47 "/usr/include/qt4/QtCore/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:
    friend class QTransform;





    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)
{
    xp = qRound(xp/c);
    yp = qRound(yp/c);
    return *this;
}

inline const QPoint operator/(const QPoint &p, qreal c)
{
    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);

    qreal manhattanLength() const;

    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;
    friend class QTransform;

    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 qFuzzyIsNull(p1.xp - p2.xp) && qFuzzyIsNull(p1.yp - p2.yp);
}

inline bool operator!=(const QPointF &p1, const QPointF &p2)
{
    return !qFuzzyIsNull(p1.xp - p2.xp) || !qFuzzyIsNull(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)
{
    xp/=c;
    yp/=c;
    return *this;
}

inline const QPointF operator/(const QPointF &p, qreal c)
{
    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);





# 47 "/usr/include/qt4/QtCore/qrect.h" 2









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;
# 85 "/usr/include/qt4/QtCore/qrect.h"
    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 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);



    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 united(const QRect &other) const;
    QRect intersect(const QRect &r) const;
    QRect intersected(const QRect &other) const;
    bool intersects(const QRect &r) const;

    friend inline bool operator==(const QRect &, const QRect &);
    friend inline bool operator!=(const QRect &, const QRect &);







private:

    friend void qt_setCoords(QRect *r, int xp1, int yp1, int xp2, int yp2);
# 182 "/usr/include/qt4/QtCore/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;
}
# 431 "/usr/include/qt4/QtCore/qrect.h"
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::intersected(const QRect &other) const
{
    return intersect(other);
}

inline QRect QRect::unite(const QRect &r) const
{
    return *this | r;
}

inline QRect QRect::united(const QRect &r) const
{
     return unite(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(const QPointF &topleft, const QPointF &bottomRight);
    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 united(const QRectF &other) const;
    QRectF intersect(const QRectF &r) const;
    QRectF intersected(const QRectF &other) 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;
    QRect toAlignedRect() 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 QPointF &atopLeft, const QPointF &abottomRight)
{
    xp = atopLeft.x();
    yp = atopLeft.y();
    w = abottomRight.x() - xp;
    h = abottomRight.y() - yp;
}

inline QRectF::QRectF(const QRect &r)
    : xp(r.x()), yp(r.y()), w(r.width()), h(r.height())
{
}

inline bool QRectF::isNull() const
{ return w == 0. && h == 0.; }

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::intersected(const QRectF &r) const
{
    return intersect(r);
}

inline QRectF QRectF::unite(const QRectF &r) const
{
    return *this | r;
}

inline QRectF QRectF::united(const QRectF &r) const
{
    return unite(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 &);





# 47 "/usr/include/qt4/QtGui/qpaintdevice.h" 2





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;
# 91 "/usr/include/qt4/QtGui/qpaintdevice.h"
    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 colorCount() const { return metric(PdmNumColors); }
    int depth() const { return metric(PdmDepth); }

public:
    QPaintDevice();
    virtual int metric(PaintDeviceMetric metric) const;

    ushort painters;

private:
    QPaintDevice(const QPaintDevice &); QPaintDevice &operator=(const QPaintDevice &);
# 140 "/usr/include/qt4/QtGui/qpaintdevice.h"
    friend class QPainter;
    friend class QFontEngineMac;
    friend class QX11PaintEngine;
    friend int qt_paint_device_metric(const QPaintDevice *device, PaintDeviceMetric metric);
};
# 167 "/usr/include/qt4/QtGui/qpaintdevice.h"
inline int QPaintDevice::devType() const
{ return QInternal::UnknownDevice; }

inline bool QPaintDevice::paintingActive() const
{ return painters != 0; }




# 46 "/usr/include/qt4/QtGui/qpixmap.h" 2
# 1 "/usr/include/qt4/QtGui/qcolor.h" 1
# 45 "/usr/include/qt4/QtGui/qcolor.h"
# 1 "/usr/include/qt4/QtGui/qrgb.h" 1
# 47 "/usr/include/qt4/QtGui/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 (0xffu << 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); }




# 46 "/usr/include/qt4/QtGui/qcolor.h" 2

# 1 "/usr/include/qt4/QtCore/qstringlist.h" 1
# 45 "/usr/include/qt4/QtCore/qstringlist.h"
# 1 "/usr/include/qt4/QtCore/qalgorithms.h" 1
# 47 "/usr/include/qt4/QtCore/qalgorithms.h"




typedef QtValidLicenseForCoreModule QtCoreModule;





namespace QAlgorithmsPrivate {

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

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

template <typename RandomAccessIterator, typename T, typename LessThan>
 RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
template <typename RandomAccessIterator, typename T, typename LessThan>
 RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
template <typename RandomAccessIterator, typename T, typename LessThan>
 RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);

}

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 Container, typename T>
inline void qFill(Container &container, const T &val)
{
    qFill(container.begin(), container.end(), 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 Container, typename T>
inline typename Container::const_iterator qFind(const Container &container, const T &val)
{
    return qFind(container.constBegin(), container.constEnd(), val);
}

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 Container, typename T, typename Size>
inline void qCount(const Container &container, const T &value, Size &n)
{
    qCount(container.constBegin(), container.constEnd(), value, n);
}
# 155 "/usr/include/qt4/QtCore/qalgorithms.h"
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 RandomAccessIterator>
inline void qSort(RandomAccessIterator start, RandomAccessIterator end)
{
    if (start != end)
        QAlgorithmsPrivate::qSortHelper(start, end, *start);
}

template <typename RandomAccessIterator, typename LessThan>
inline void qSort(RandomAccessIterator start, RandomAccessIterator 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 RandomAccessIterator>
inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end)
{
    if (start != end)
        QAlgorithmsPrivate::qStableSortHelper(start, end, *start);
}

template <typename RandomAccessIterator, typename LessThan>
inline void qStableSort(RandomAccessIterator start, RandomAccessIterator 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, typename LessThan>
 RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
{
    return QAlgorithmsPrivate::qLowerBoundHelper(begin, end, value, lessThan);
}

template <typename Container, typename T>
 typename Container::const_iterator qLowerBound(const Container &container, const T &value)
{
    return QAlgorithmsPrivate::qLowerBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
}

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, typename LessThan>
 RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
{
    return QAlgorithmsPrivate::qUpperBoundHelper(begin, end, value, lessThan);
}

template <typename Container, typename T>
 typename Container::const_iterator qUpperBound(const Container &container, const T &value)
{
    return QAlgorithmsPrivate::qUpperBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
}

template <typename RandomAccessIterator, typename T>
 RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
{

    RandomAccessIterator it = qLowerBound(begin, end, value);

    if (it == end || value < *it)
        return end;

    return it;
}

template <typename RandomAccessIterator, typename T, typename LessThan>
 RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
{
    return QAlgorithmsPrivate::qBinaryFindHelper(begin, end, value, lessThan);
}

template <typename Container, typename T>
 typename Container::const_iterator qBinaryFind(const Container &container, const T &value)
{
    return QAlgorithmsPrivate::qBinaryFindHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
}

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 RandomAccessIterator, typename T, typename LessThan>
 void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan)
{
top:
    int span = int(end - start);
    if (span < 2)
        return;

    --end;
    RandomAccessIterator low = start, high = end - 1;
    RandomAccessIterator 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 RandomAccessIterator, typename T>
inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
{
    qSortHelper(begin, end, dummy, qLess<T>());
}

template <typename RandomAccessIterator>
 void qReverse(RandomAccessIterator begin, RandomAccessIterator end)
{
    --end;
    while (begin < end)
        qSwap(*begin++, *end--);
}

template <typename RandomAccessIterator>
 void qRotate(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end)
{
    qReverse(begin, middle);
    qReverse(middle, end);
    qReverse(begin, end);
}

template <typename RandomAccessIterator, typename T, typename LessThan>
 void qMerge(RandomAccessIterator begin, RandomAccessIterator pivot, RandomAccessIterator end, T &t, LessThan lessThan)
{
    const int len1 = pivot - begin;
    const int len2 = end - pivot;

    if (len1 == 0 || len2 == 0)
        return;

    if (len1 + len2 == 2) {
        if (lessThan(*(begin + 1), *(begin)))
            qSwap(*begin, *(begin + 1));
        return;
    }

    RandomAccessIterator firstCut;
    RandomAccessIterator secondCut;
    int len2Half;
    if (len1 > len2) {
        const int len1Half = len1 / 2;
        firstCut = begin + len1Half;
        secondCut = qLowerBound(pivot, end, *firstCut, lessThan);
        len2Half = secondCut - pivot;
    } else {
        len2Half = len2 / 2;
        secondCut = pivot + len2Half;
        firstCut = qUpperBound(begin, pivot, *secondCut, lessThan);
    }

    qRotate(firstCut, pivot, secondCut);
    const RandomAccessIterator newPivot = firstCut + len2Half;
    qMerge(begin, firstCut, newPivot, t, lessThan);
    qMerge(newPivot, secondCut, end, t, lessThan);
}

template <typename RandomAccessIterator, typename T, typename LessThan>
 void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &t, LessThan lessThan)
{
    const int span = end - begin;
    if (span < 2)
       return;

    const RandomAccessIterator middle = begin + span / 2;
    qStableSortHelper(begin, middle, t, lessThan);
    qStableSortHelper(middle, end, t, lessThan);
    qMerge(begin, middle, end, t, lessThan);
}

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

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

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


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

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

template <typename RandomAccessIterator, typename T, typename LessThan>
 RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
{
    RandomAccessIterator it = qLowerBoundHelper(begin, end, value, lessThan);

    if (it == end || lessThan(value, *it))
        return end;

    return it;
}

}




# 46 "/usr/include/qt4/QtCore/qstringlist.h" 2
# 1 "/usr/include/qt4/QtCore/qdatastream.h" 1
# 45 "/usr/include/qt4/QtCore/qdatastream.h"
# 1 "/usr/include/qt4/QtCore/qscopedpointer.h" 1
# 47 "/usr/include/qt4/QtCore/qscopedpointer.h"


typedef QtValidLicenseForCoreModule QtCoreModule;

template <typename T>
struct QScopedPointerDeleter
{
    static inline void cleanup(T *pointer)
    {



        typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ];
        (void) sizeof(IsIncompleteType);

        delete pointer;
    }
};

template <typename T>
struct QScopedPointerArrayDeleter
{
    static inline void cleanup(T *pointer)
    {



        typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ];
        (void) sizeof(IsIncompleteType);

        delete [] pointer;
    }
};

struct QScopedPointerPodDeleter
{
    static inline void cleanup(void *pointer) { if (pointer) qFree(pointer); }
};

template <typename T, typename Cleanup = QScopedPointerDeleter<T> >
class QScopedPointer
{

    typedef T *QScopedPointer:: *RestrictedBool;

public:
    explicit inline QScopedPointer(T *p = 0) : d(p)
    {
    }

    inline ~QScopedPointer()
    {
        T *oldD = this->d;
        Cleanup::cleanup(oldD);
        this->d = 0;
    }

    inline T &operator*() const
    {
        ((!(d)) ? qt_assert("d","/usr/include/qt4/QtCore/qscopedpointer.h",106) : qt_noop());
        return *d;
    }

    inline T *operator->() const
    {
        ((!(d)) ? qt_assert("d","/usr/include/qt4/QtCore/qscopedpointer.h",112) : qt_noop());
        return d;
    }

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







    inline operator RestrictedBool() const
    {
        return isNull() ? 0 : &QScopedPointer::d;
    }


    inline T *data() const
    {
        return d;
    }

    inline bool isNull() const
    {
        return !d;
    }

    inline void reset(T *other = 0)
    {
        if (d == other)
            return;
        T *oldD = d;
        d = other;
        Cleanup::cleanup(oldD);
    }

    inline T *take()
    {
        T *oldD = d;
        d = 0;
        return oldD;
    }

    inline void swap(QScopedPointer<T, Cleanup> &other)
    {
        qSwap(d, other.d);
    }

    typedef T *pointer;

public:
    T *d;

private:
    QScopedPointer(const QScopedPointer &); QScopedPointer &operator=(const QScopedPointer &);
};

template <class T, class Cleanup>
inline bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
{
    return lhs.data() == rhs.data();
}

template <class T, class Cleanup>
inline bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
{
    return lhs.data() != rhs.data();
}

template <class T, class Cleanup>
inline void qSwap(QScopedPointer<T, Cleanup> &p1, QScopedPointer<T, Cleanup> &p2)
{ p1.swap(p2); }

template <typename T, typename Cleanup = QScopedPointerArrayDeleter<T> >
class QScopedArrayPointer : public QScopedPointer<T, Cleanup>
{
public:
    explicit inline QScopedArrayPointer(T *p = 0)
        : QScopedPointer<T, Cleanup>(p)
    {
    }

    inline T &operator[](int i)
    {
        return this->d[i];
    }

    inline const T &operator[](int i) const
    {
        return this->d[i];
    }

private:
    QScopedArrayPointer(const QScopedArrayPointer &); QScopedArrayPointer &operator=(const QScopedArrayPointer &);
};



# 46 "/usr/include/qt4/QtCore/qdatastream.h" 2
# 1 "/usr/include/qt4/QtCore/qiodevice.h" 1
# 46 "/usr/include/qt4/QtCore/qiodevice.h"
# 1 "/usr/include/qt4/QtCore/qobject.h" 1
# 50 "/usr/include/qt4/QtCore/qobject.h"
# 1 "/usr/include/qt4/QtCore/qlist.h" 1
# 45 "/usr/include/qt4/QtCore/qlist.h"
# 1 "/usr/include/qt4/QtCore/qiterator.h" 1
# 47 "/usr/include/qt4/QtCore/qiterator.h"


namespace std {
    struct bidirectional_iterator_tag;
    struct random_access_iterator_tag;
}



typedef QtValidLicenseForCoreModule QtCoreModule;
# 198 "/usr/include/qt4/QtCore/qiterator.h"



# 46 "/usr/include/qt4/QtCore/qlist.h" 2




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 3
       
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 2 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 3
       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 3





# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3





namespace std __attribute__ ((__visibility__ ("default"))) {
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
  class locale
  {
  public:


    typedef int category;


    class facet;
    class id;
    class _Impl;

    friend class facet;
    friend class _Impl;

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Cache>
      friend struct __use_cache;
# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    static const category none = 0;
    static const category ctype = 1L << 0;
    static const category numeric = 1L << 1;
    static const category collate = 1L << 2;
    static const category time = 1L << 3;
    static const category monetary = 1L << 4;
    static const category messages = 1L << 5;
    static const category all = (ctype | numeric | collate |
        time | monetary | messages);
# 117 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    locale() throw();
# 126 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    locale(const locale& __other) throw();
# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    explicit
    locale(const char* __s);
# 151 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    locale(const locale& __base, const char* __s, category __cat);
# 164 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    locale(const locale& __base, const locale& __add, category __cat);
# 176 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);


    ~locale() throw();
# 190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    const locale&
    operator=(const locale& __other) throw();
# 205 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    template<typename _Facet>
      locale
      combine(const locale& __other) const;






    string
    name() const;
# 224 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    bool
    operator==(const locale& __other) const throw();







    bool
    operator!=(const locale& __other) const throw()
    { return !(this->operator==(__other)); }
# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    template<typename _Char, typename _Traits, typename _Alloc>
      bool
      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
# 268 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    static locale
    global(const locale&);




    static const locale&
    classic();

  private:

    _Impl* _M_impl;


    static _Impl* _S_classic;


    static _Impl* _S_global;





    static const char* const* const _S_categories;
# 303 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    enum { _S_categories_size = 6 + 6 };


    static __gthread_once_t _S_once;


    explicit
    locale(_Impl*) throw();

    static void
    _S_initialize();

    static void
    _S_initialize_once() throw();

    static category
    _S_normalize_category(category);

    void
    _M_coalesce(const locale& __base, const locale& __add, category __cat);
  };
# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
  class locale::facet
  {
  private:
    friend class locale;
    friend class locale::_Impl;

    mutable _Atomic_word _M_refcount;


    static __c_locale _S_c_locale;


    static const char _S_c_name[2];


    static __gthread_once_t _S_once;


    static void
    _S_initialize_once();

  public:
# 368 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
    explicit
    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
    { }


    virtual
    ~facet();

    static void
    _S_create_c_locale(__c_locale& __cloc, const char* __s,
         __c_locale __old = 0);

    static __c_locale
    _S_clone_c_locale(__c_locale& __cloc) throw();

    static void
    _S_destroy_c_locale(__c_locale& __cloc);

    static __c_locale
    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);



    static __c_locale
    _S_get_c_locale();

    __attribute__ ((__const__)) static const char*
    _S_get_c_name() throw();

  private:
    void
    _M_add_reference() const throw()
    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

    void
    _M_remove_reference() const throw()
    {
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
 {
   try
     { delete this; }
   catch(...)
     { }
 }
    }

    facet(const facet&);

    facet&
    operator=(const facet&);
  };
# 432 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
  class locale::id
  {
  private:
    friend class locale;
    friend class locale::_Impl;

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();




    mutable size_t _M_index;


    static _Atomic_word _S_refcount;

    void
    operator=(const id&);

    id(const id&);

  public:



    id() { }

    size_t
    _M_id() const throw();
  };



  class locale::_Impl
  {
  public:

    friend class locale;
    friend class locale::facet;

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Cache>
      friend struct __use_cache;

  private:

    _Atomic_word _M_refcount;
    const facet** _M_facets;
    size_t _M_facets_size;
    const facet** _M_caches;
    char** _M_names;
    static const locale::id* const _S_id_ctype[];
    static const locale::id* const _S_id_numeric[];
    static const locale::id* const _S_id_collate[];
    static const locale::id* const _S_id_time[];
    static const locale::id* const _S_id_monetary[];
    static const locale::id* const _S_id_messages[];
    static const locale::id* const* const _S_facet_categories[];

    void
    _M_add_reference() throw()
    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

    void
    _M_remove_reference() throw()
    {
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
 {
   try
     { delete this; }
   catch(...)
     { }
 }
    }

    _Impl(const _Impl&, size_t);
    _Impl(const char*, size_t);
    _Impl(size_t) throw();

   ~_Impl() throw();

    _Impl(const _Impl&);

    void
    operator=(const _Impl&);

    bool
    _M_check_same_name()
    {
      bool __ret = true;
      if (_M_names[1])

 for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
      return __ret;
    }

    void
    _M_replace_categories(const _Impl*, category);

    void
    _M_replace_category(const _Impl*, const locale::id* const*);

    void
    _M_replace_facet(const _Impl*, const locale::id*);

    void
    _M_install_facet(const locale::id*, const facet*);

    template<typename _Facet>
      void
      _M_init_facet(_Facet* __facet)
      { _M_install_facet(&_Facet::id, __facet); }

    void
    _M_install_cache(const facet*, size_t);
  };
# 575 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw();
# 592 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc);
# 609 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
  template<typename _CharT>
    class collate : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


    public:


      __c_locale _M_c_locale_collate;

    public:

      static locale::id id;
# 636 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
      explicit
      collate(size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
      { }
# 650 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
      explicit
      collate(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
      { }
# 667 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
      int
      compare(const _CharT* __lo1, const _CharT* __hi1,
       const _CharT* __lo2, const _CharT* __hi2) const
      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
# 686 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_transform(__lo, __hi); }
# 700 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
      long
      hash(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_hash(__lo, __hi); }


      int
      _M_compare(const _CharT*, const _CharT*) const throw();

      size_t
      _M_transform(_CharT*, const _CharT*, size_t) const throw();

  public:

      virtual
      ~collate()
      { _S_destroy_c_locale(_M_c_locale_collate); }
# 729 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
   const _CharT* __lo2, const _CharT* __hi2) const;
# 745 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 758 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
      virtual long
      do_hash(const _CharT* __lo, const _CharT* __hi) const;
    };

  template<typename _CharT>
    locale::id collate<_CharT>::id;


  template<>
    int
    collate<char>::_M_compare(const char*, const char*) const throw();

  template<>
    size_t
    collate<char>::_M_transform(char*, const char*, size_t) const throw();


  template<>
    int
    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();

  template<>
    size_t
    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();



  template<typename _CharT>
    class collate_byname : public collate<_CharT>
    {
    public:


      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


      explicit
      collate_byname(const char* __s, size_t __refs = 0)
      : collate<_CharT>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_collate);
     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
   }
      }

    public:
      virtual
      ~collate_byname() { }
    };

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.tcc" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.tcc" 3
       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.tcc" 3

namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _Facet>
    locale::
    locale(const locale& __other, _Facet* __f)
    {
      _M_impl = new _Impl(*__other._M_impl, 1);

      try
 { _M_impl->_M_install_facet(&_Facet::id, __f); }
      catch(...)
 {
   _M_impl->_M_remove_reference();
   throw;
 }
      delete [] _M_impl->_M_names[0];
      _M_impl->_M_names[0] = 0;
    }

  template<typename _Facet>
    locale
    locale::
    combine(const locale& __other) const
    {
      _Impl* __tmp = new _Impl(*_M_impl, 1);
      try
 {
   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
 }
      catch(...)
 {
   __tmp->_M_remove_reference();
   throw;
 }
      return locale(__tmp);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    bool
    locale::
    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
    {
      typedef std::collate<_CharT> __collate_type;
      const __collate_type& __collate = use_facet<__collate_type>(*this);
      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
    __s2.data(), __s2.data() + __s2.length()) < 0);
    }


  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw()
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;
      return (__i < __loc._M_impl->_M_facets_size

       && dynamic_cast<const _Facet*>(__facets[__i]));



    }

  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc)
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;
      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
        __throw_bad_cast();

      return dynamic_cast<const _Facet&>(*__facets[__i]);



    }



  template<typename _CharT>
    int
    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
    { return 0; }


  template<typename _CharT>
    size_t
    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
    { return 0; }

  template<typename _CharT>
    int
    collate<_CharT>::
    do_compare(const _CharT* __lo1, const _CharT* __hi1,
        const _CharT* __lo2, const _CharT* __hi2) const
    {


      const string_type __one(__lo1, __hi1);
      const string_type __two(__lo2, __hi2);

      const _CharT* __p = __one.c_str();
      const _CharT* __pend = __one.data() + __one.length();
      const _CharT* __q = __two.c_str();
      const _CharT* __qend = __two.data() + __two.length();




      for (;;)
 {
   const int __res = _M_compare(__p, __q);
   if (__res)
     return __res;

   __p += char_traits<_CharT>::length(__p);
   __q += char_traits<_CharT>::length(__q);
   if (__p == __pend && __q == __qend)
     return 0;
   else if (__p == __pend)
     return -1;
   else if (__q == __qend)
     return 1;

   __p++;
   __q++;
 }
    }

  template<typename _CharT>
    typename collate<_CharT>::string_type
    collate<_CharT>::
    do_transform(const _CharT* __lo, const _CharT* __hi) const
    {
      string_type __ret;


      const string_type __str(__lo, __hi);

      const _CharT* __p = __str.c_str();
      const _CharT* __pend = __str.data() + __str.length();

      size_t __len = (__hi - __lo) * 2;

      _CharT* __c = new _CharT[__len];

      try
 {



   for (;;)
     {

       size_t __res = _M_transform(__c, __p, __len);


       if (__res >= __len)
  {
    __len = __res + 1;
    delete [] __c, __c = 0;
    __c = new _CharT[__len];
    __res = _M_transform(__c, __p, __len);
  }

       __ret.append(__c, __res);
       __p += char_traits<_CharT>::length(__p);
       if (__p == __pend)
  break;

       __p++;
       __ret.push_back(_CharT());
     }
 }
      catch(...)
 {
   delete [] __c;
   throw;
 }

      delete [] __c;

      return __ret;
    }

  template<typename _CharT>
    long
    collate<_CharT>::
    do_hash(const _CharT* __lo, const _CharT* __hi) const
    {
      unsigned long __val = 0;
      for (; __lo < __hi; ++__lo)
 __val =
   *__lo + ((__val << 7)
     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
    __digits - 7)));
      return static_cast<long>(__val);
    }





  extern template class collate<char>;
  extern template class collate_byname<char>;

  extern template
    const collate<char>&
    use_facet<collate<char> >(const locale&);

  extern template
    bool
    has_facet<collate<char> >(const locale&);


  extern template class collate<wchar_t>;
  extern template class collate_byname<wchar_t>;

  extern template
    const collate<wchar_t>&
    use_facet<collate<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<collate<wchar_t> >(const locale&);



}
# 816 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 2 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 2 3
# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {





  enum _Ios_Fmtflags
    {
      _S_boolalpha = 1L << 0,
      _S_dec = 1L << 1,
      _S_fixed = 1L << 2,
      _S_hex = 1L << 3,
      _S_internal = 1L << 4,
      _S_left = 1L << 5,
      _S_oct = 1L << 6,
      _S_right = 1L << 7,
      _S_scientific = 1L << 8,
      _S_showbase = 1L << 9,
      _S_showpoint = 1L << 10,
      _S_showpos = 1L << 11,
      _S_skipws = 1L << 12,
      _S_unitbuf = 1L << 13,
      _S_uppercase = 1L << 14,
      _S_adjustfield = _S_left | _S_right | _S_internal,
      _S_basefield = _S_dec | _S_oct | _S_hex,
      _S_floatfield = _S_scientific | _S_fixed,
      _S_ios_fmtflags_end = 1L << 16
    };

  inline _Ios_Fmtflags
  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline _Ios_Fmtflags
  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline _Ios_Fmtflags
  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline _Ios_Fmtflags&
  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a | __b; }

  inline _Ios_Fmtflags&
  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a & __b; }

  inline _Ios_Fmtflags&
  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a ^ __b; }

  inline _Ios_Fmtflags
  operator~(_Ios_Fmtflags __a)
  { return _Ios_Fmtflags(~static_cast<int>(__a)); }


  enum _Ios_Openmode
    {
      _S_app = 1L << 0,
      _S_ate = 1L << 1,
      _S_bin = 1L << 2,
      _S_in = 1L << 3,
      _S_out = 1L << 4,
      _S_trunc = 1L << 5,
      _S_ios_openmode_end = 1L << 16
    };

  inline _Ios_Openmode
  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline _Ios_Openmode
  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline _Ios_Openmode
  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline _Ios_Openmode&
  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a | __b; }

  inline _Ios_Openmode&
  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a & __b; }

  inline _Ios_Openmode&
  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a ^ __b; }

  inline _Ios_Openmode
  operator~(_Ios_Openmode __a)
  { return _Ios_Openmode(~static_cast<int>(__a)); }


  enum _Ios_Iostate
    {
      _S_goodbit = 0,
      _S_badbit = 1L << 0,
      _S_eofbit = 1L << 1,
      _S_failbit = 1L << 2,
      _S_ios_iostate_end = 1L << 16
    };

  inline _Ios_Iostate
  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline _Ios_Iostate
  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline _Ios_Iostate
  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline _Ios_Iostate&
  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a | __b; }

  inline _Ios_Iostate&
  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a & __b; }

  inline _Ios_Iostate&
  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a ^ __b; }

  inline _Ios_Iostate
  operator~(_Ios_Iostate __a)
  { return _Ios_Iostate(~static_cast<int>(__a)); }

  enum _Ios_Seekdir
    {
      _S_beg = 0,
      _S_cur = 1,
      _S_end = 2,
      _S_ios_seekdir_end = 1L << 16
    };
# 207 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
  class ios_base
  {
  public:







    class failure : public exception
    {
    public:


      explicit
      failure(const string& __str) throw();



      virtual
      ~failure() throw();

      virtual const char*
      what() const throw();

    private:
      string _M_msg;
    };
# 263 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    typedef _Ios_Fmtflags fmtflags;


    static const fmtflags boolalpha = _S_boolalpha;


    static const fmtflags dec = _S_dec;


    static const fmtflags fixed = _S_fixed;


    static const fmtflags hex = _S_hex;




    static const fmtflags internal = _S_internal;



    static const fmtflags left = _S_left;


    static const fmtflags oct = _S_oct;



    static const fmtflags right = _S_right;


    static const fmtflags scientific = _S_scientific;



    static const fmtflags showbase = _S_showbase;



    static const fmtflags showpoint = _S_showpoint;


    static const fmtflags showpos = _S_showpos;


    static const fmtflags skipws = _S_skipws;


    static const fmtflags unitbuf = _S_unitbuf;



    static const fmtflags uppercase = _S_uppercase;


    static const fmtflags adjustfield = _S_adjustfield;


    static const fmtflags basefield = _S_basefield;


    static const fmtflags floatfield = _S_floatfield;
# 338 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    typedef _Ios_Iostate iostate;



    static const iostate badbit = _S_badbit;


    static const iostate eofbit = _S_eofbit;




    static const iostate failbit = _S_failbit;


    static const iostate goodbit = _S_goodbit;
# 369 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    typedef _Ios_Openmode openmode;


    static const openmode app = _S_app;


    static const openmode ate = _S_ate;




    static const openmode binary = _S_bin;


    static const openmode in = _S_in;


    static const openmode out = _S_out;


    static const openmode trunc = _S_trunc;
# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    typedef _Ios_Seekdir seekdir;


    static const seekdir beg = _S_beg;


    static const seekdir cur = _S_cur;


    static const seekdir end = _S_end;


    typedef int io_state;
    typedef int open_mode;
    typedef int seek_dir;

    typedef std::streampos streampos;
    typedef std::streamoff streamoff;
# 427 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };
# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    typedef void (*event_callback) (event, ios_base&, int);
# 456 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    void
    register_callback(event_callback __fn, int __index);

  public:
    streamsize _M_precision;
    streamsize _M_width;
    fmtflags _M_flags;
    iostate _M_exception;
    iostate _M_streambuf_state;



    struct _Callback_list
    {

      _Callback_list* _M_next;
      ios_base::event_callback _M_fn;
      int _M_index;
      _Atomic_word _M_refcount;

      _Callback_list(ios_base::event_callback __fn, int __index,
       _Callback_list* __cb)
      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }

      void
      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }


      int
      _M_remove_reference()
      { return __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1); }
    };

     _Callback_list* _M_callbacks;

    void
    _M_call_callbacks(event __ev) throw();

    void
    _M_dispose_callbacks(void) throw();


    struct _Words
    {
      void* _M_pword;
      long _M_iword;
      _Words() : _M_pword(0), _M_iword(0) { }
    };


    _Words _M_word_zero;



    enum { _S_local_word_size = 8 };
    _Words _M_local_word[_S_local_word_size];


    int _M_word_size;
    _Words* _M_word;

    _Words&
    _M_grow_words(int __index, bool __iword);


    locale _M_ios_locale;

    void
    _M_init() throw();

  public:





    class Init
    {
      friend class ios_base;
    public:
      Init();
      ~Init();

    private:
      static _Atomic_word _S_refcount;
      static bool _S_synced_with_stdio;
    };






    fmtflags
    flags() const
    { return _M_flags; }
# 560 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }
# 576 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }
# 593 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl, fmtflags __mask)
    {
      fmtflags __old = _M_flags;
      _M_flags &= ~__mask;
      _M_flags |= (__fmtfl & __mask);
      return __old;
    }







    void
    unsetf(fmtflags __mask)
    { _M_flags &= ~__mask; }
# 619 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    streamsize
    precision() const
    { return _M_precision; }






    streamsize
    precision(streamsize __prec)
    {
      streamsize __old = _M_precision;
      _M_precision = __prec;
      return __old;
    }







    streamsize
    width() const
    { return _M_width; }






    streamsize
    width(streamsize __wide)
    {
      streamsize __old = _M_width;
      _M_width = __wide;
      return __old;
    }
# 670 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    static bool
    sync_with_stdio(bool __sync = true);
# 682 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    locale
    imbue(const locale& __loc) throw();
# 693 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    locale
    getloc() const
    { return _M_ios_locale; }
# 704 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    const locale&
    _M_getloc() const
    { return _M_ios_locale; }
# 723 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    static int
    xalloc() throw();
# 739 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    long&
    iword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, true);
      return __word._M_iword;
    }
# 760 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    void*&
    pword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, false);
      return __word._M_pword;
    }
# 777 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
    virtual ~ios_base();

  public:
    ios_base() throw ();



  private:
    ios_base(const ios_base&);

    ios_base&
    operator=(const ios_base&);
  };



  inline ios_base&
  boolalpha(ios_base& __base)
  {
    __base.setf(ios_base::boolalpha);
    return __base;
  }


  inline ios_base&
  noboolalpha(ios_base& __base)
  {
    __base.unsetf(ios_base::boolalpha);
    return __base;
  }


  inline ios_base&
  showbase(ios_base& __base)
  {
    __base.setf(ios_base::showbase);
    return __base;
  }


  inline ios_base&
  noshowbase(ios_base& __base)
  {
    __base.unsetf(ios_base::showbase);
    return __base;
  }


  inline ios_base&
  showpoint(ios_base& __base)
  {
    __base.setf(ios_base::showpoint);
    return __base;
  }


  inline ios_base&
  noshowpoint(ios_base& __base)
  {
    __base.unsetf(ios_base::showpoint);
    return __base;
  }


  inline ios_base&
  showpos(ios_base& __base)
  {
    __base.setf(ios_base::showpos);
    return __base;
  }


  inline ios_base&
  noshowpos(ios_base& __base)
  {
    __base.unsetf(ios_base::showpos);
    return __base;
  }


  inline ios_base&
  skipws(ios_base& __base)
  {
    __base.setf(ios_base::skipws);
    return __base;
  }


  inline ios_base&
  noskipws(ios_base& __base)
  {
    __base.unsetf(ios_base::skipws);
    return __base;
  }


  inline ios_base&
  uppercase(ios_base& __base)
  {
    __base.setf(ios_base::uppercase);
    return __base;
  }


  inline ios_base&
  nouppercase(ios_base& __base)
  {
    __base.unsetf(ios_base::uppercase);
    return __base;
  }


  inline ios_base&
  unitbuf(ios_base& __base)
  {
     __base.setf(ios_base::unitbuf);
     return __base;
  }


  inline ios_base&
  nounitbuf(ios_base& __base)
  {
     __base.unsetf(ios_base::unitbuf);
     return __base;
  }



  inline ios_base&
  internal(ios_base& __base)
  {
     __base.setf(ios_base::internal, ios_base::adjustfield);
     return __base;
  }


  inline ios_base&
  left(ios_base& __base)
  {
    __base.setf(ios_base::left, ios_base::adjustfield);
    return __base;
  }


  inline ios_base&
  right(ios_base& __base)
  {
    __base.setf(ios_base::right, ios_base::adjustfield);
    return __base;
  }



  inline ios_base&
  dec(ios_base& __base)
  {
    __base.setf(ios_base::dec, ios_base::basefield);
    return __base;
  }


  inline ios_base&
  hex(ios_base& __base)
  {
    __base.setf(ios_base::hex, ios_base::basefield);
    return __base;
  }


  inline ios_base&
  oct(ios_base& __base)
  {
    __base.setf(ios_base::oct, ios_base::basefield);
    return __base;
  }



  inline ios_base&
  fixed(ios_base& __base)
  {
    __base.setf(ios_base::fixed, ios_base::floatfield);
    return __base;
  }


  inline ios_base&
  scientific(ios_base& __base)
  {
    __base.setf(ios_base::scientific, ios_base::floatfield);
    return __base;
  }

}
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
     basic_streambuf<_CharT, _Traits>*, bool&);
# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
  template<typename _CharT, typename _Traits>
    class basic_streambuf
    {
    public:






      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;




      typedef basic_streambuf<char_type, traits_type> __streambuf_type;


      friend class basic_ios<char_type, traits_type>;
      friend class basic_istream<char_type, traits_type>;
      friend class basic_ostream<char_type, traits_type>;
      friend class istreambuf_iterator<char_type, traits_type>;
      friend class ostreambuf_iterator<char_type, traits_type>;

      friend streamsize
      __copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&);

      template<bool _IsMove, typename _CharT2>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
        __copy_move_a2(istreambuf_iterator<_CharT2>,
         istreambuf_iterator<_CharT2>, _CharT2*);

      template<typename _CharT2>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
      istreambuf_iterator<_CharT2> >::__type
        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      const _CharT2&);

      template<typename _CharT2, typename _Traits2>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);

      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&,
     basic_string<_CharT2, _Traits2, _Alloc>&);

      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        getline(basic_istream<_CharT2, _Traits2>&,
  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);

    public:
# 180 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      char_type* _M_in_beg;
      char_type* _M_in_cur;
      char_type* _M_in_end;
      char_type* _M_out_beg;
      char_type* _M_out_cur;
      char_type* _M_out_end;


      locale _M_buf_locale;

  public:

      virtual
      ~basic_streambuf()
      { }
# 204 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      locale
      pubimbue(const locale &__loc)
      {
 locale __tmp(this->getloc());
 this->imbue(__loc);
 _M_buf_locale = __loc;
 return __tmp;
      }
# 221 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      locale
      getloc() const
      { return _M_buf_locale; }
# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      __streambuf_type*
      pubsetbuf(char_type* __s, streamsize __n)
      { return this->setbuf(__s, __n); }

      pos_type
      pubseekoff(off_type __off, ios_base::seekdir __way,
   ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekoff(__off, __way, __mode); }

      pos_type
      pubseekpos(pos_type __sp,
   ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekpos(__sp, __mode); }

      int
      pubsync() { return this->sync(); }
# 261 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      streamsize
      in_avail()
      {
 const streamsize __ret = this->egptr() - this->gptr();
 return __ret ? __ret : this->showmanyc();
      }
# 275 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      int_type
      snextc()
      {
 int_type __ret = traits_type::eof();
 if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
             __ret), true))
   __ret = this->sgetc();
 return __ret;
      }
# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      int_type
      sbumpc()
      {
 int_type __ret;
 if (__builtin_expect(this->gptr() < this->egptr(), true))
   {
     __ret = traits_type::to_int_type(*this->gptr());
     this->gbump(1);
   }
 else
   __ret = this->uflow();
 return __ret;
      }
# 315 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      int_type
      sgetc()
      {
 int_type __ret;
 if (__builtin_expect(this->gptr() < this->egptr(), true))
   __ret = traits_type::to_int_type(*this->gptr());
 else
   __ret = this->underflow();
 return __ret;
      }
# 334 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }
# 349 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      int_type
      sputbackc(char_type __c)
      {
 int_type __ret;
 const bool __testpos = this->eback() < this->gptr();
 if (__builtin_expect(!__testpos ||
        !traits_type::eq(__c, this->gptr()[-1]), false))
   __ret = this->pbackfail(traits_type::to_int_type(__c));
 else
   {
     this->gbump(-1);
     __ret = traits_type::to_int_type(*this->gptr());
   }
 return __ret;
      }
# 374 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      int_type
      sungetc()
      {
 int_type __ret;
 if (__builtin_expect(this->eback() < this->gptr(), true))
   {
     this->gbump(-1);
     __ret = traits_type::to_int_type(*this->gptr());
   }
 else
   __ret = this->pbackfail();
 return __ret;
      }
# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      int_type
      sputc(char_type __c)
      {
 int_type __ret;
 if (__builtin_expect(this->pptr() < this->epptr(), true))
   {
     *this->pptr() = __c;
     this->pbump(1);
     __ret = traits_type::to_int_type(__c);
   }
 else
   __ret = this->overflow(traits_type::to_int_type(__c));
 return __ret;
      }
# 427 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    public:
# 441 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      basic_streambuf()
      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
      _M_buf_locale(locale())
      { }
# 459 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      char_type*
      eback() const { return _M_in_beg; }

      char_type*
      gptr() const { return _M_in_cur; }

      char_type*
      egptr() const { return _M_in_end; }
# 475 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      void
      gbump(int __n) { _M_in_cur += __n; }
# 486 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      void
      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
      {
 _M_in_beg = __gbeg;
 _M_in_cur = __gnext;
 _M_in_end = __gend;
      }
# 506 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      char_type*
      pbase() const { return _M_out_beg; }

      char_type*
      pptr() const { return _M_out_cur; }

      char_type*
      epptr() const { return _M_out_end; }
# 522 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      void
      pbump(int __n) { _M_out_cur += __n; }
# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      void
      setp(char_type* __pbeg, char_type* __pend)
      {
 _M_out_beg = _M_out_cur = __pbeg;
 _M_out_end = __pend;
      }
# 553 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual void
      imbue(const locale&)
      { }
# 568 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }
# 579 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual pos_type
      seekoff(off_type, ios_base::seekdir,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 591 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual pos_type
      seekpos(pos_type,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual int
      sync() { return 0; }
# 626 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual streamsize
      showmanyc() { return 0; }
# 642 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);
# 664 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual int_type
      underflow()
      { return traits_type::eof(); }
# 677 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual int_type
      uflow()
      {
 int_type __ret = traits_type::eof();
 const bool __testeof = traits_type::eq_int_type(this->underflow(),
       __ret);
 if (!__testeof)
   {
     __ret = traits_type::to_int_type(*this->gptr());
     this->gbump(1);
   }
 return __ret;
      }
# 701 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual int_type
      pbackfail(int_type = traits_type::eof())
      { return traits_type::eof(); }
# 719 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);
# 745 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      virtual int_type
      overflow(int_type = traits_type::eof())
      { return traits_type::eof(); }



    public:
# 760 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
      void
      stossc()
      {
 if (this->gptr() < this->egptr())
   this->gbump(1);
 else
   this->uflow();
      }


    private:


      basic_streambuf(const __streambuf_type& __sb)
      : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
      _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
      _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
      _M_buf_locale(__sb._M_buf_locale)
      { }

      __streambuf_type&
      operator=(const __streambuf_type&) { return *this; };
    };


  template<>
    streamsize
    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
     basic_streambuf<char>* __sbout, bool& __ineof);

  template<>
    streamsize
    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
     basic_streambuf<wchar_t>* __sbout, bool& __ineof);


}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf.tcc" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf.tcc" 3
       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf.tcc" 3

namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsgetn(char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const streamsize __buf_len = this->egptr() - this->gptr();
   if (__buf_len)
     {
       const streamsize __remaining = __n - __ret;
       const streamsize __len = std::min(__buf_len, __remaining);
       traits_type::copy(__s, this->gptr(), __len);
       __ret += __len;
       __s += __len;
       this->gbump(__len);
     }

   if (__ret < __n)
     {
       const int_type __c = this->uflow();
       if (!traits_type::eq_int_type(__c, traits_type::eof()))
  {
    traits_type::assign(*__s++, traits_type::to_char_type(__c));
    ++__ret;
  }
       else
  break;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsputn(const char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const streamsize __buf_len = this->epptr() - this->pptr();
   if (__buf_len)
     {
       const streamsize __remaining = __n - __ret;
       const streamsize __len = std::min(__buf_len, __remaining);
       traits_type::copy(this->pptr(), __s, __len);
       __ret += __len;
       __s += __len;
       this->pbump(__len);
     }

   if (__ret < __n)
     {
       int_type __c = this->overflow(traits_type::to_int_type(*__s));
       if (!traits_type::eq_int_type(__c, traits_type::eof()))
  {
    ++__ret;
    ++__s;
  }
       else
  break;
     }
 }
      return __ret;
    }




  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
     basic_streambuf<_CharT, _Traits>* __sbout,
     bool& __ineof)
    {
      streamsize __ret = 0;
      __ineof = true;
      typename _Traits::int_type __c = __sbin->sgetc();
      while (!_Traits::eq_int_type(__c, _Traits::eof()))
 {
   __c = __sbout->sputc(_Traits::to_char_type(__c));
   if (_Traits::eq_int_type(__c, _Traits::eof()))
     {
       __ineof = false;
       break;
     }
   ++__ret;
   __c = __sbin->snextc();
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    inline streamsize
    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
        basic_streambuf<_CharT, _Traits>* __sbout)
    {
      bool __ineof;
      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
    }





  extern template class basic_streambuf<char>;
  extern template
    streamsize
    __copy_streambufs(basic_streambuf<char>*,
        basic_streambuf<char>*);
  extern template
    streamsize
    __copy_streambufs_eof(basic_streambuf<char>*,
     basic_streambuf<char>*, bool&);


  extern template class basic_streambuf<wchar_t>;
  extern template
    streamsize
    __copy_streambufs(basic_streambuf<wchar_t>*,
        basic_streambuf<wchar_t>*);
  extern template
    streamsize
    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
     basic_streambuf<wchar_t>*, bool&);



}
# 800 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
       
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwctype" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwctype" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwctype" 3




# 1 "/usr/include/wctype.h" 1 3 4
# 34 "/usr/include/wctype.h" 3 4
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 35 "/usr/include/wctype.h" 2 3 4
# 50 "/usr/include/wctype.h" 3 4



typedef unsigned long int wctype_t;

# 72 "/usr/include/wctype.h" 3 4
enum
{
  __ISwupper = 0,
  __ISwlower = 1,
  __ISwalpha = 2,
  __ISwdigit = 3,
  __ISwxdigit = 4,
  __ISwspace = 5,
  __ISwprint = 6,
  __ISwgraph = 7,
  __ISwblank = 8,
  __ISwcntrl = 9,
  __ISwpunct = 10,
  __ISwalnum = 11,

  _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
};



extern "C" {








extern int iswalnum (wint_t __wc) throw ();





extern int iswalpha (wint_t __wc) throw ();


extern int iswcntrl (wint_t __wc) throw ();



extern int iswdigit (wint_t __wc) throw ();



extern int iswgraph (wint_t __wc) throw ();




extern int iswlower (wint_t __wc) throw ();


extern int iswprint (wint_t __wc) throw ();




extern int iswpunct (wint_t __wc) throw ();




extern int iswspace (wint_t __wc) throw ();




extern int iswupper (wint_t __wc) throw ();




extern int iswxdigit (wint_t __wc) throw ();





extern int iswblank (wint_t __wc) throw ();
# 172 "/usr/include/wctype.h" 3 4
extern wctype_t wctype (__const char *__property) throw ();



extern int iswctype (wint_t __wc, wctype_t __desc) throw ();










typedef __const __int32_t *wctrans_t;







extern wint_t towlower (wint_t __wc) throw ();


extern wint_t towupper (wint_t __wc) throw ();


}
# 214 "/usr/include/wctype.h" 3 4
extern "C" {




extern wctrans_t wctrans (__const char *__property) throw ();


extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();








extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();





extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();


extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();



extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();



extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();


extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();



extern wctype_t wctype_l (__const char *__property, __locale_t __locale)
     throw ();



extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
     throw ();







extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();


extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();



extern wctrans_t wctrans_l (__const char *__property, __locale_t __locale)
     throw ();


extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
      __locale_t __locale) throw ();



}
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwctype" 2 3
# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwctype" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  using ::wctrans_t;
  using ::wctype_t;
  using ::wint_t;

  using ::iswalnum;
  using ::iswalpha;

  using ::iswblank;

  using ::iswcntrl;
  using ::iswctype;
  using ::iswdigit;
  using ::iswgraph;
  using ::iswlower;
  using ::iswprint;
  using ::iswpunct;
  using ::iswspace;
  using ::iswupper;
  using ::iswxdigit;
  using ::towctrans;
  using ::towlower;
  using ::towupper;
  using ::wctrans;
  using ::wctype;

}
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 3
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_base.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_base.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {


  struct ctype_base
  {

    typedef const int* __to_type;



    typedef unsigned short mask;
    static const mask upper = _ISupper;
    static const mask lower = _ISlower;
    static const mask alpha = _ISalpha;
    static const mask digit = _ISdigit;
    static const mask xdigit = _ISxdigit;
    static const mask space = _ISspace;
    static const mask print = _ISprint;
    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
    static const mask cntrl = _IScntrl;
    static const mask punct = _ISpunct;
    static const mask alnum = _ISalpha | _ISdigit;
  };

}
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3






# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf_iterator.h" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf_iterator.h" 3
       
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf_iterator.h" 3




namespace std __attribute__ ((__visibility__ ("default"))) {
# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf_iterator.h" 3
  template<typename _CharT, typename _Traits>
    class istreambuf_iterator
    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
        _CharT*, _CharT&>
    {
    public:



      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename _Traits::int_type int_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_istream<_CharT, _Traits> istream_type;


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
                      ostreambuf_iterator<_CharT2> >::__type
 copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      ostreambuf_iterator<_CharT2>);

      template<bool _IsMove, typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
 __copy_move_a2(istreambuf_iterator<_CharT2>,
         istreambuf_iterator<_CharT2>, _CharT2*);

      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
               istreambuf_iterator<_CharT2> >::__type
 find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      const _CharT2&);

    private:







      mutable streambuf_type* _M_sbuf;
      mutable int_type _M_c;

    public:

      istreambuf_iterator() throw()
      : _M_sbuf(0), _M_c(traits_type::eof()) { }


      istreambuf_iterator(istream_type& __s) throw()
      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }


      istreambuf_iterator(streambuf_type* __s) throw()
      : _M_sbuf(__s), _M_c(traits_type::eof()) { }




      char_type
      operator*() const
      {







 return traits_type::to_char_type(_M_get());
      }


      istreambuf_iterator&
      operator++()
      {


                        ;
 if (_M_sbuf)
   {
     _M_sbuf->sbumpc();
     _M_c = traits_type::eof();
   }
 return *this;
      }


      istreambuf_iterator
      operator++(int)
      {


                        ;

 istreambuf_iterator __old = *this;
 if (_M_sbuf)
   {
     __old._M_c = _M_sbuf->sbumpc();
     _M_c = traits_type::eof();
   }
 return __old;
      }





      bool
      equal(const istreambuf_iterator& __b) const
      { return _M_at_eof() == __b._M_at_eof(); }

    private:
      int_type
      _M_get() const
      {
 const int_type __eof = traits_type::eof();
 int_type __ret = __eof;
 if (_M_sbuf)
   {
     if (!traits_type::eq_int_type(_M_c, __eof))
       __ret = _M_c;
     else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
            __eof))
       _M_c = __ret;
     else
       _M_sbuf = 0;
   }
 return __ret;
      }

      bool
      _M_at_eof() const
      {
 const int_type __eof = traits_type::eof();
 return traits_type::eq_int_type(_M_get(), __eof);
      }
    };

  template<typename _CharT, typename _Traits>
    inline bool
    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
        const istreambuf_iterator<_CharT, _Traits>& __b)
    { return __a.equal(__b); }

  template<typename _CharT, typename _Traits>
    inline bool
    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
        const istreambuf_iterator<_CharT, _Traits>& __b)
    { return !__a.equal(__b); }


  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:



      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
                      ostreambuf_iterator<_CharT2> >::__type
 copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      ostreambuf_iterator<_CharT2>);

    private:
      streambuf_type* _M_sbuf;
      bool _M_failed;

    public:

      ostreambuf_iterator(ostream_type& __s) throw ()
      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator(streambuf_type* __s) throw ()
      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator&
      operator=(_CharT __c)
      {
 if (!_M_failed &&
     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
   _M_failed = true;
 return *this;
      }


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


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


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


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

      ostreambuf_iterator&
      _M_put(const _CharT* __ws, streamsize __len)
      {
 if (__builtin_expect(!_M_failed, true)
     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
    false))
   _M_failed = true;
 return *this;
      }
    };


  template<typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
                           ostreambuf_iterator<_CharT> >::__type
    copy(istreambuf_iterator<_CharT> __first,
  istreambuf_iterator<_CharT> __last,
  ostreambuf_iterator<_CharT> __result)
    {
      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
 {
   bool __ineof;
   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
   if (!__ineof)
     __result._M_failed = true;
 }
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
            ostreambuf_iterator<_CharT> >::__type
    __copy_move_a2(_CharT* __first, _CharT* __last,
     ostreambuf_iterator<_CharT> __result)
    {
      const streamsize __num = __last - __first;
      if (__num > 0)
 __result._M_put(__first, __num);
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    __copy_move_a2(const _CharT* __first, const _CharT* __last,
     ostreambuf_iterator<_CharT> __result)
    {
      const streamsize __num = __last - __first;
      if (__num > 0)
 __result._M_put(__first, __num);
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
            _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT> __first,
     istreambuf_iterator<_CharT> __last, _CharT* __result)
    {
      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;

      if (__first._M_sbuf && !__last._M_sbuf)
 {
   streambuf_type* __sb = __first._M_sbuf;
   int_type __c = __sb->sgetc();
   while (!traits_type::eq_int_type(__c, traits_type::eof()))
     {
       const streamsize __n = __sb->egptr() - __sb->gptr();
       if (__n > 1)
  {
    traits_type::copy(__result, __sb->gptr(), __n);
    __sb->gbump(__n);
    __result += __n;
    __c = __sb->underflow();
  }
       else
  {
    *__result++ = traits_type::to_char_type(__c);
    __c = __sb->snextc();
  }
     }
 }
      return __result;
    }

  template<typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
          istreambuf_iterator<_CharT> >::__type
    find(istreambuf_iterator<_CharT> __first,
  istreambuf_iterator<_CharT> __last, const _CharT& __val)
    {
      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;

      if (__first._M_sbuf && !__last._M_sbuf)
 {
   const int_type __ival = traits_type::to_int_type(__val);
   streambuf_type* __sb = __first._M_sbuf;
   int_type __c = __sb->sgetc();
   while (!traits_type::eq_int_type(__c, traits_type::eof())
   && !traits_type::eq_int_type(__c, __ival))
     {
       streamsize __n = __sb->egptr() - __sb->gptr();
       if (__n > 1)
  {
    const _CharT* __p = traits_type::find(__sb->gptr(),
       __n, __val);
    if (__p)
      __n = __p - __sb->gptr();
    __sb->gbump(__n);
    __c = __sb->sgetc();
  }
       else
  __c = __sb->snextc();
     }

   if (!traits_type::eq_int_type(__c, traits_type::eof()))
     __first._M_c = __c;
   else
     __first._M_sbuf = 0;
 }
      return __first;
    }



}
# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
  template<typename _Tp>
    void
    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
     const __c_locale&) throw();


  template<>
    void
    __convert_to_v(const char*, float&, ios_base::iostate&,
     const __c_locale&) throw();

  template<>
    void
    __convert_to_v(const char*, double&, ios_base::iostate&,
     const __c_locale&) throw();

  template<>
    void
    __convert_to_v(const char*, long double&, ios_base::iostate&,
     const __c_locale&) throw();



  template<typename _CharT, typename _Traits>
    struct __pad
    {
      static void
      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
    };






  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last);




  template<typename _CharT>
    inline
    ostreambuf_iterator<_CharT>
    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
    {
      __s._M_put(__ws, __len);
      return __s;
    }


  template<typename _CharT, typename _OutIter>
    inline
    _OutIter
    __write(_OutIter __s, const _CharT* __ws, int __len)
    {
      for (int __j = 0; __j < __len; __j++, ++__s)
 *__s = __ws[__j];
      return __s;
    }
# 142 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:


      typedef _CharT char_type;
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }
# 177 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
      { return this->do_is(__lo, __hi, __vec); }
# 193 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_is(__m, __lo, __hi); }
# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_not(__m, __lo, __hi); }
# 223 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 238 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 284 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      { return this->do_widen(__c); }
# 303 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      { return this->do_widen(__lo, __hi, __to); }
# 322 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }
# 344 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
       char __dfault, char *__to) const
      { return this->do_narrow(__lo, __hi, __dfault, __to); }

    public:
      explicit
      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }

      virtual
      ~__ctype_abstract_base() { }
# 369 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const = 0;
# 388 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
     mask* __vec) const = 0;
# 407 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
   const char_type* __hi) const = 0;
# 426 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const = 0;
# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const = 0;
# 461 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
# 477 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const = 0;
# 494 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
# 513 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char) const = 0;
# 534 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi,
        char_type* __dest) const = 0;
# 556 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type, char __dfault) const = 0;
# 580 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __dest) const = 0;
    };
# 603 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
  template<typename _CharT>
    class ctype : public __ctype_abstract_base<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef typename __ctype_abstract_base<_CharT>::mask mask;


      static locale::id id;

      explicit
      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }

   public:
      virtual
      ~ctype();

      virtual bool
      do_is(mask __m, char_type __c) const;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;

      virtual char_type
      do_toupper(char_type __c) const;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_tolower(char_type __c) const;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_widen(char __c) const;

      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

      virtual char
      do_narrow(char_type, char __dfault) const;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __dest) const;
    };

  template<typename _CharT>
    locale::id ctype<_CharT>::id;
# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
  template<>
    class ctype<char> : public locale::facet, public ctype_base
    {
    public:


      typedef char char_type;

    public:

      __c_locale _M_c_locale_ctype;
      bool _M_del;
      __to_type _M_toupper;
      __to_type _M_tolower;
      const mask* _M_table;
      mutable char _M_widen_ok;
      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
      mutable char _M_narrow_ok;


    public:

      static locale::id id;

      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
# 709 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 722 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
     size_t __refs = 0);
# 735 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      inline bool
      is(mask __m, char __c) const;
# 750 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;
# 764 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      inline const char*
      scan_is(mask __m, const char* __lo, const char* __hi) const;
# 778 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      inline const char*
      scan_not(mask __m, const char* __lo, const char* __hi) const;
# 793 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 810 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 826 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 843 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 863 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      {
 if (_M_widen_ok)
   return _M_widen[static_cast<unsigned char>(__c)];
 this->_M_widen_init();
 return this->do_widen(__c);
      }
# 890 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      {
 if (_M_widen_ok == 1)
   {
     __builtin_memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_widen_ok)
   _M_widen_init();
 return this->do_widen(__lo, __hi, __to);
      }
# 921 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      {
 if (_M_narrow[static_cast<unsigned char>(__c)])
   return _M_narrow[static_cast<unsigned char>(__c)];
 const char __t = do_narrow(__c, __dfault);
 if (__t != __dfault)
   _M_narrow[static_cast<unsigned char>(__c)] = __t;
 return __t;
      }
# 954 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
      char __dfault, char *__to) const
      {
 if (__builtin_expect(_M_narrow_ok == 1, true))
   {
     __builtin_memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_narrow_ok)
   _M_narrow_init();
 return this->do_narrow(__lo, __hi, __dfault, __to);
      }





      const mask*
      table() const throw()
      { return _M_table; }


      static const mask*
      classic_table() throw();
    public:







      virtual
      ~ctype();
# 1003 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const;
# 1020 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1036 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const;
# 1053 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1073 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const
      { return __c; }
# 1096 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const
      {
 __builtin_memcpy(__dest, __lo, __hi - __lo);
 return __hi;
      }
# 1122 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char) const
      { return __c; }
# 1148 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char, char* __dest) const
      {
 __builtin_memcpy(__dest, __lo, __hi - __lo);
 return __hi;
      }

    private:
      void _M_narrow_init() const;
      void _M_widen_init() const;
    };
# 1173 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
  template<>
    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
    {
    public:


      typedef wchar_t char_type;
      typedef wctype_t __wmask_type;

    public:
      __c_locale _M_c_locale_ctype;


      bool _M_narrow_ok;
      char _M_narrow[128];
      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];


      mask _M_bit[16];
      __wmask_type _M_wmask[16];

    public:


      static locale::id id;
# 1206 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      explicit
      ctype(size_t __refs = 0);
# 1217 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, size_t __refs = 0);

    public:
      __wmask_type
      _M_convert_to_wmask(const mask __m) const throw();


      virtual
      ~ctype();
# 1241 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const;
# 1260 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
# 1278 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
# 1296 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;
# 1313 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const;
# 1330 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1346 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const;
# 1363 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1383 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char) const;
# 1405 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
# 1428 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type, char __dfault) const;
# 1454 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __dest) const;


      void
      _M_initialize_ctype() throw();
    };



  template<typename _CharT>
    class ctype_byname : public ctype<_CharT>
    {
    public:
      typedef typename ctype<_CharT>::mask mask;

      explicit
      ctype_byname(const char* __s, size_t __refs = 0);

    public:
      virtual
      ~ctype_byname() { };
    };


  template<>
    class ctype_byname<char> : public ctype<char>
    {
    public:
      explicit
      ctype_byname(const char* __s, size_t __refs = 0);

    public:
      virtual
      ~ctype_byname();
    };


  template<>
    class ctype_byname<wchar_t> : public ctype<wchar_t>
    {
    public:
      explicit
      ctype_byname(const char* __s, size_t __refs = 0);

    public:
      virtual
      ~ctype_byname();
    };


}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_inline.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_inline.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  bool
  ctype<char>::
  is(mask __m, char __c) const
  { return _M_table[static_cast<unsigned char>(__c)] & __m; }

  const char*
  ctype<char>::
  is(const char* __low, const char* __high, mask* __vec) const
  {
    while (__low < __high)
      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
    return __high;
  }

  const char*
  ctype<char>::
  scan_is(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
    && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
      ++__low;
    return __low;
  }

  const char*
  ctype<char>::
  scan_not(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
    && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
      ++__low;
    return __low;
  }

}
# 1510 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {


  class __num_base
  {
  public:


    enum
      {
        _S_ominus,
        _S_oplus,
        _S_ox,
        _S_oX,
        _S_odigits,
        _S_odigits_end = _S_odigits + 16,
        _S_oudigits = _S_odigits_end,
        _S_oudigits_end = _S_oudigits + 16,
        _S_oe = _S_odigits + 14,
        _S_oE = _S_oudigits + 14,
 _S_oend = _S_oudigits_end
      };






    static const char* _S_atoms_out;



    static const char* _S_atoms_in;

    enum
    {
      _S_iminus,
      _S_iplus,
      _S_ix,
      _S_iX,
      _S_izero,
      _S_ie = _S_izero + 14,
      _S_iE = _S_izero + 20,
      _S_iend = 26
    };



    static void
    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
  };

  template<typename _CharT>
    struct __numpunct_cache : public locale::facet
    {
      const char* _M_grouping;
      size_t _M_grouping_size;
      bool _M_use_grouping;
      const _CharT* _M_truename;
      size_t _M_truename_size;
      const _CharT* _M_falsename;
      size_t _M_falsename_size;
      _CharT _M_decimal_point;
      _CharT _M_thousands_sep;





      _CharT _M_atoms_out[__num_base::_S_oend];





      _CharT _M_atoms_in[__num_base::_S_iend];

      bool _M_allocated;

      __numpunct_cache(size_t __refs = 0) : facet(__refs),
      _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
      _M_truename(__null), _M_truename_size(0), _M_falsename(__null),
      _M_falsename_size(0), _M_decimal_point(_CharT()),
      _M_thousands_sep(_CharT()), _M_allocated(false)
      { }

      ~__numpunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __numpunct_cache&
      operator=(const __numpunct_cache&);

      explicit
      __numpunct_cache(const __numpunct_cache&);
    };

  template<typename _CharT>
    __numpunct_cache<_CharT>::~__numpunct_cache()
    {
      if (_M_allocated)
 {
   delete [] _M_grouping;
   delete [] _M_truename;
   delete [] _M_falsename;
 }
    }
# 1635 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
  template<typename _CharT>
    class numpunct : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      typedef __numpunct_cache<_CharT> __cache_type;

    public:
      __cache_type* _M_data;

    public:

      static locale::id id;






      explicit
      numpunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
      { _M_initialize_numpunct(); }
# 1672 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      explicit
      numpunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_numpunct(); }
# 1686 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      explicit
      numpunct(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_data(__null)
      { _M_initialize_numpunct(__cloc); }
# 1700 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1713 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1744 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1757 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      string_type
      truename() const
      { return this->do_truename(); }
# 1770 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      string_type
      falsename() const
      { return this->do_falsename(); }

    public:

      virtual
      ~numpunct();
# 1787 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1799 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1812 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1825 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual string_type
      do_truename() const
      { return _M_data->_M_truename; }
# 1838 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual string_type
      do_falsename() const
      { return _M_data->_M_falsename; }


      void
      _M_initialize_numpunct(__c_locale __cloc = __null);
    };

  template<typename _CharT>
    locale::id numpunct<_CharT>::id;

  template<>
    numpunct<char>::~numpunct();

  template<>
    void
    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);


  template<>
    numpunct<wchar_t>::~numpunct();

  template<>
    void
    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);



  template<typename _CharT>
    class numpunct_byname : public numpunct<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      numpunct_byname(const char* __s, size_t __refs = 0)
      : numpunct<_CharT>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_numpunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }

    public:
      virtual
      ~numpunct_byname() { }
    };


# 1908 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
  template<typename _CharT, typename _InIter>
    class num_get : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;



      static locale::id id;
# 1929 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      explicit
      num_get(size_t __refs = 0) : facet(__refs) { }
# 1955 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, bool& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 1991 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned short& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned int& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }


      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned long long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 2050 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, float& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, double& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long double& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 2092 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, void*& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

    public:

      virtual ~num_get() { }

      iter_type
      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
         string&) const;

      template<typename _ValueT>
        iter_type
        _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
         _ValueT&) const;

      template<typename _CharT2>
      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
        _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
        {
   int __ret = -1;
   if (__len <= 10)
     {
       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
  __ret = __c - _CharT2('0');
     }
   else
     {
       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
  __ret = __c - _CharT2('0');
       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
  __ret = 10 + (__c - _CharT2('a'));
       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
  __ret = 10 + (__c - _CharT2('A'));
     }
   return __ret;
 }

      template<typename _CharT2>
      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
          int>::__type
        _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
        {
   int __ret = -1;
   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
   if (__q)
     {
       __ret = __q - __zero;
       if (__ret > 15)
  __ret -= 6;
     }
   return __ret;
 }
# 2163 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned short& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned int& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }


      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, long long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned long long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
      float&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
      double&) const;







      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
      long double&) const;


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
      void*&) const;
# 2228 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
    };

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;
# 2246 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
  template<typename _CharT, typename _OutIter>
    class num_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 2267 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      explicit
      num_put(size_t __refs = 0) : facet(__refs) { }
# 2285 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
      { return this->do_put(__s, __f, __fill, __v); }
# 2327 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
      { return this->do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
   unsigned long __v) const
      { return this->do_put(__s, __f, __fill, __v); }


      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
      { return this->do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
   unsigned long long __v) const
      { return this->do_put(__s, __f, __fill, __v); }
# 2390 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
      { return this->do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
   long double __v) const
      { return this->do_put(__s, __f, __fill, __v); }
# 2415 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
   const void* __v) const
      { return this->do_put(__s, __f, __fill, __v); }

    public:
      template<typename _ValueT>
        iter_type
        _M_insert_float(iter_type, ios_base& __io, char_type __fill,
   char __mod, _ValueT __v) const;

      void
      _M_group_float(const char* __grouping, size_t __grouping_size,
       char_type __sep, const char_type* __p, char_type* __new,
       char_type* __cs, int& __len) const;

      template<typename _ValueT>
        iter_type
        _M_insert_int(iter_type, ios_base& __io, char_type __fill,
        _ValueT __v) const;

      void
      _M_group_int(const char* __grouping, size_t __grouping_size,
     char_type __sep, ios_base& __io, char_type* __new,
     char_type* __cs, int& __len) const;

      void
      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
      char_type* __new, const char_type* __cs, int& __len) const;


      virtual
      ~num_put() { };
# 2463 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, bool __v) const;

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      unsigned long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }


      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      long long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      unsigned long long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }


      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, double __v) const;






      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, long double __v) const;


      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;







    };

  template <typename _CharT, typename _OutIter>
    locale::id num_put<_CharT, _OutIter>::id;









  template<typename _CharT>
    inline bool
    isspace(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }


  template<typename _CharT>
    inline bool
    isprint(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }


  template<typename _CharT>
    inline bool
    iscntrl(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }


  template<typename _CharT>
    inline bool
    isupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }


  template<typename _CharT>
    inline bool
    islower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }


  template<typename _CharT>
    inline bool
    isalpha(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }


  template<typename _CharT>
    inline bool
    isdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }


  template<typename _CharT>
    inline bool
    ispunct(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }


  template<typename _CharT>
    inline bool
    isxdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }


  template<typename _CharT>
    inline bool
    isalnum(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }


  template<typename _CharT>
    inline bool
    isgraph(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }


  template<typename _CharT>
    inline _CharT
    toupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }


  template<typename _CharT>
    inline _CharT
    tolower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
       
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3

namespace std __attribute__ ((__visibility__ ("default"))) {



  template<typename _Facet>
    struct __use_cache
    {
      const _Facet*
      operator() (const locale& __loc) const;
    };


  template<typename _CharT>
    struct __use_cache<__numpunct_cache<_CharT> >
    {
      const __numpunct_cache<_CharT>*
      operator() (const locale& __loc) const
      {
 const size_t __i = numpunct<_CharT>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __numpunct_cache<_CharT>* __tmp = __null;
     try
       {
  __tmp = new __numpunct_cache<_CharT>;
  __tmp->_M_cache(__loc);
       }
     catch(...)
       {
  delete __tmp;
  throw;
       }
     __loc._M_impl->_M_install_cache(__tmp, __i);
   }
 return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
      }
    };

  template<typename _CharT>
    void
    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
    {
      _M_allocated = true;

      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);

      char* __grouping = 0;
      _CharT* __truename = 0;
      _CharT* __falsename = 0;
      try
 {
   _M_grouping_size = __np.grouping().size();
   __grouping = new char[_M_grouping_size];
   __np.grouping().copy(__grouping, _M_grouping_size);
   _M_grouping = __grouping;
   _M_use_grouping = (_M_grouping_size
        && static_cast<signed char>(_M_grouping[0]) > 0
        && (_M_grouping[0]
     != __gnu_cxx::__numeric_traits<char>::__max));

   _M_truename_size = __np.truename().size();
   __truename = new _CharT[_M_truename_size];
   __np.truename().copy(__truename, _M_truename_size);
   _M_truename = __truename;

   _M_falsename_size = __np.falsename().size();
   __falsename = new _CharT[_M_falsename_size];
   __np.falsename().copy(__falsename, _M_falsename_size);
   _M_falsename = __falsename;

   _M_decimal_point = __np.decimal_point();
   _M_thousands_sep = __np.thousands_sep();

   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
   __ct.widen(__num_base::_S_atoms_out,
       __num_base::_S_atoms_out
       + __num_base::_S_oend, _M_atoms_out);
   __ct.widen(__num_base::_S_atoms_in,
       __num_base::_S_atoms_in
       + __num_base::_S_iend, _M_atoms_in);
 }
      catch(...)
 {
   delete [] __grouping;
   delete [] __truename;
   delete [] __falsename;
   throw;
 }
    }
# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
  __attribute__ ((__pure__)) bool
  __verify_grouping(const char* __grouping, size_t __grouping_size,
      const string& __grouping_tmp) throw ();



  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
       ios_base::iostate& __err, string& __xtrc) const
    {
      typedef char_traits<_CharT> __traits_type;
      typedef __numpunct_cache<_CharT> __cache_type;
      __use_cache<__cache_type> __uc;
      const locale& __loc = __io._M_getloc();
      const __cache_type* __lc = __uc(__loc);
      const _CharT* __lit = __lc->_M_atoms_in;
      char_type __c = char_type();


      bool __testeof = __beg == __end;


      if (!__testeof)
 {
   __c = *__beg;
   const bool __plus = __c == __lit[__num_base::_S_iplus];
   if ((__plus || __c == __lit[__num_base::_S_iminus])
       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       && !(__c == __lc->_M_decimal_point))
     {
       __xtrc += __plus ? '+' : '-';
       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }
 }


      bool __found_mantissa = false;
      int __sep_pos = 0;
      while (!__testeof)
 {
   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       || __c == __lc->_M_decimal_point)
     break;
   else if (__c == __lit[__num_base::_S_izero])
     {
       if (!__found_mantissa)
  {
    __xtrc += '0';
    __found_mantissa = true;
  }
       ++__sep_pos;

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }
   else
     break;
 }


      bool __found_dec = false;
      bool __found_sci = false;
      string __found_grouping;
      if (__lc->_M_use_grouping)
 __found_grouping.reserve(32);
      const char_type* __lit_zero = __lit + __num_base::_S_izero;

      if (!__lc->_M_allocated)

 while (!__testeof)
   {
     const int __digit = _M_find(__lit_zero, 10, __c);
     if (__digit != -1)
       {
  __xtrc += '0' + __digit;
  __found_mantissa = true;
       }
     else if (__c == __lc->_M_decimal_point
       && !__found_dec && !__found_sci)
       {
  __xtrc += '.';
  __found_dec = true;
       }
     else if ((__c == __lit[__num_base::_S_ie]
        || __c == __lit[__num_base::_S_iE])
       && !__found_sci && __found_mantissa)
       {

  __xtrc += 'e';
  __found_sci = true;


  if (++__beg != __end)
    {
      __c = *__beg;
      const bool __plus = __c == __lit[__num_base::_S_iplus];
      if (__plus || __c == __lit[__num_base::_S_iminus])
        __xtrc += __plus ? '+' : '-';
      else
        continue;
    }
  else
    {
      __testeof = true;
      break;
    }
       }
     else
       break;

     if (++__beg != __end)
       __c = *__beg;
     else
       __testeof = true;
   }
      else
 while (!__testeof)
   {


     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       {
  if (!__found_dec && !__found_sci)
    {


      if (__sep_pos)
        {
   __found_grouping += static_cast<char>(__sep_pos);
   __sep_pos = 0;
        }
      else
        {


   __xtrc.clear();
   break;
        }
    }
  else
    break;
       }
     else if (__c == __lc->_M_decimal_point)
       {
  if (!__found_dec && !__found_sci)
    {



      if (__found_grouping.size())
        __found_grouping += static_cast<char>(__sep_pos);
      __xtrc += '.';
      __found_dec = true;
    }
  else
    break;
       }
     else
       {
  const char_type* __q =
    __traits_type::find(__lit_zero, 10, __c);
  if (__q)
    {
      __xtrc += '0' + (__q - __lit_zero);
      __found_mantissa = true;
      ++__sep_pos;
    }
  else if ((__c == __lit[__num_base::_S_ie]
     || __c == __lit[__num_base::_S_iE])
    && !__found_sci && __found_mantissa)
    {

      if (__found_grouping.size() && !__found_dec)
        __found_grouping += static_cast<char>(__sep_pos);
      __xtrc += 'e';
      __found_sci = true;


      if (++__beg != __end)
        {
   __c = *__beg;
   const bool __plus = __c == __lit[__num_base::_S_iplus];
   if ((__plus || __c == __lit[__num_base::_S_iminus])
       && !(__lc->_M_use_grouping
     && __c == __lc->_M_thousands_sep)
       && !(__c == __lc->_M_decimal_point))
        __xtrc += __plus ? '+' : '-';
   else
     continue;
        }
      else
        {
   __testeof = true;
   break;
        }
    }
  else
    break;
       }

     if (++__beg != __end)
       __c = *__beg;
     else
       __testeof = true;
   }



      if (__found_grouping.size())
        {

   if (!__found_dec && !__found_sci)
     __found_grouping += static_cast<char>(__sep_pos);

          if (!std::__verify_grouping(__lc->_M_grouping,
          __lc->_M_grouping_size,
          __found_grouping))
     __err = ios_base::failbit;
        }

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    template<typename _ValueT>
      _InIter
      num_get<_CharT, _InIter>::
      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
       ios_base::iostate& __err, _ValueT& __v) const
      {
        typedef char_traits<_CharT> __traits_type;
 using __gnu_cxx::__add_unsigned;
 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_in;
 char_type __c = char_type();


 const ios_base::fmtflags __basefield = __io.flags()
                                        & ios_base::basefield;
 const bool __oct = __basefield == ios_base::oct;
 int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);


 bool __testeof = __beg == __end;


 bool __negative = false;
 if (!__testeof)
   {
     __c = *__beg;
     __negative = __c == __lit[__num_base::_S_iminus];
     if ((__negative || __c == __lit[__num_base::_S_iplus])
  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  && !(__c == __lc->_M_decimal_point))
       {
  if (++__beg != __end)
    __c = *__beg;
  else
    __testeof = true;
       }
   }



 bool __found_zero = false;
 int __sep_pos = 0;
 while (!__testeof)
   {
     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  || __c == __lc->_M_decimal_point)
       break;
     else if (__c == __lit[__num_base::_S_izero]
       && (!__found_zero || __base == 10))
       {
  __found_zero = true;
  ++__sep_pos;
  if (__basefield == 0)
    __base = 8;
  if (__base == 8)
    __sep_pos = 0;
       }
     else if (__found_zero
       && (__c == __lit[__num_base::_S_ix]
    || __c == __lit[__num_base::_S_iX]))
       {
  if (__basefield == 0)
    __base = 16;
  if (__base == 16)
    {
      __found_zero = false;
      __sep_pos = 0;
    }
  else
    break;
       }
     else
       break;

     if (++__beg != __end)
       {
  __c = *__beg;
  if (!__found_zero)
    break;
       }
     else
       __testeof = true;
   }



 const size_t __len = (__base == 16 ? __num_base::_S_iend
         - __num_base::_S_izero : __base);


 string __found_grouping;
 if (__lc->_M_use_grouping)
   __found_grouping.reserve(32);
 bool __testfail = false;
 bool __testoverflow = false;
 const __unsigned_type __max =
   (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
   ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
   : __gnu_cxx::__numeric_traits<_ValueT>::__max;
 const __unsigned_type __smax = __max / __base;
 __unsigned_type __result = 0;
 int __digit = 0;
 const char_type* __lit_zero = __lit + __num_base::_S_izero;

 if (!__lc->_M_allocated)

   while (!__testeof)
     {
       __digit = _M_find(__lit_zero, __len, __c);
       if (__digit == -1)
  break;

       if (__result > __smax)
  __testoverflow = true;
       else
  {
    __result *= __base;
    __testoverflow |= __result > __max - __digit;
    __result += __digit;
    ++__sep_pos;
  }

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }
 else
   while (!__testeof)
     {


       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  {


    if (__sep_pos)
      {
        __found_grouping += static_cast<char>(__sep_pos);
        __sep_pos = 0;
      }
    else
      {
        __testfail = true;
        break;
      }
  }
       else if (__c == __lc->_M_decimal_point)
  break;
       else
  {
    const char_type* __q =
      __traits_type::find(__lit_zero, __len, __c);
    if (!__q)
      break;

    __digit = __q - __lit_zero;
    if (__digit > 15)
      __digit -= 6;
    if (__result > __smax)
      __testoverflow = true;
    else
      {
        __result *= __base;
        __testoverflow |= __result > __max - __digit;
        __result += __digit;
        ++__sep_pos;
      }
  }

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }



 if (__found_grouping.size())
   {

     __found_grouping += static_cast<char>(__sep_pos);

     if (!std::__verify_grouping(__lc->_M_grouping,
     __lc->_M_grouping_size,
     __found_grouping))
       __err = ios_base::failbit;
   }



 if ((!__sep_pos && !__found_zero && !__found_grouping.size())
     || __testfail)
   {
     __v = 0;
     __err = ios_base::failbit;
   }
 else if (__testoverflow)
   {
     if (__negative
  && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
       __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
     else
       __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
     __err = ios_base::failbit;
   }
 else
   __v = __negative ? -__result : __result;

 if (__testeof)
   __err |= ios_base::eofbit;
 return __beg;
      }



  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, bool& __v) const
    {
      if (!(__io.flags() & ios_base::boolalpha))
        {



   long __l = -1;
          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
   if (__l == 0 || __l == 1)
     __v = bool(__l);
   else
     {


       __v = true;
       __err = ios_base::failbit;
       if (__beg == __end)
  __err |= ios_base::eofbit;
     }
        }
      else
        {

   typedef __numpunct_cache<_CharT> __cache_type;
   __use_cache<__cache_type> __uc;
   const locale& __loc = __io._M_getloc();
   const __cache_type* __lc = __uc(__loc);

   bool __testf = true;
   bool __testt = true;
   bool __donef = __lc->_M_falsename_size == 0;
   bool __donet = __lc->_M_truename_size == 0;
   bool __testeof = false;
   size_t __n = 0;
   while (!__donef || !__donet)
     {
       if (__beg == __end)
  {
    __testeof = true;
    break;
  }

       const char_type __c = *__beg;

       if (!__donef)
  __testf = __c == __lc->_M_falsename[__n];

       if (!__testf && __donet)
  break;

       if (!__donet)
  __testt = __c == __lc->_M_truename[__n];

       if (!__testt && __donef)
  break;

       if (!__testt && !__testf)
  break;

       ++__n;
       ++__beg;

       __donef = !__testf || __n >= __lc->_M_falsename_size;
       __donet = !__testt || __n >= __lc->_M_truename_size;
     }
   if (__testf && __n == __lc->_M_falsename_size && __n)
     {
       __v = false;
       if (__testt && __n == __lc->_M_truename_size)
  __err = ios_base::failbit;
       else
  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
     }
   else if (__testt && __n == __lc->_M_truename_size && __n)
     {
       __v = true;
       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
     }
   else
     {


       __v = false;
       __err = ios_base::failbit;
       if (__testeof)
  __err |= ios_base::eofbit;
     }
 }
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, float& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, double& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }
# 730 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long double& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, void*& __v) const
    {

      typedef ios_base::fmtflags fmtflags;
      const fmtflags __fmt = __io.flags();
      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);

      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
          <= sizeof(unsigned long)),
 unsigned long, unsigned long long>::__type _UIntPtrType;

      _UIntPtrType __ul;
      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);


      __io.flags(__fmt);

      __v = reinterpret_cast<void*>(__ul);
      return __beg;
    }



  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
    _CharT* __new, const _CharT* __cs, int& __len) const
    {


      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
        __cs, __w, __len);
      __len = static_cast<int>(__w);
    }



  template<typename _CharT, typename _ValueT>
    int
    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
    ios_base::fmtflags __flags, bool __dec)
    {
      _CharT* __buf = __bufend;
      if (__builtin_expect(__dec, true))
 {

   do
     {
       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
       __v /= 10;
     }
   while (__v != 0);
 }
      else if ((__flags & ios_base::basefield) == ios_base::oct)
 {

   do
     {
       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
       __v >>= 3;
     }
   while (__v != 0);
 }
      else
 {

   const bool __uppercase = __flags & ios_base::uppercase;
   const int __case_offset = __uppercase ? __num_base::_S_oudigits
                                         : __num_base::_S_odigits;
   do
     {
       *--__buf = __lit[(__v & 0xf) + __case_offset];
       __v >>= 4;
     }
   while (__v != 0);
 }
      return __bufend - __buf;
    }



  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
    {
      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
     __grouping_size, __cs, __cs + __len);
      __len = __p - __new;
    }

  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
      _ValueT __v) const
      {
 using __gnu_cxx::__add_unsigned;
 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_out;
 const ios_base::fmtflags __flags = __io.flags();


 const int __ilen = 5 * sizeof(_ValueT);
 _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
            * __ilen));



 const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
 const bool __dec = (__basefield != ios_base::oct
       && __basefield != ios_base::hex);
 const __unsigned_type __u = ((__v > 0 || !__dec)
         ? __unsigned_type(__v)
         : -__unsigned_type(__v));
  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
 __cs += __ilen - __len;


 if (__lc->_M_use_grouping)
   {


     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * (__len + 1)
          * 2));
     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
     __cs = __cs2 + 2;
   }


 if (__builtin_expect(__dec, true))
   {

     if (__v >= 0)
       {
  if (bool(__flags & ios_base::showpos)
      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
    *--__cs = __lit[__num_base::_S_oplus], ++__len;
       }
     else
       *--__cs = __lit[__num_base::_S_ominus], ++__len;
   }
 else if (bool(__flags & ios_base::showbase) && __v)
   {
     if (__basefield == ios_base::oct)
       *--__cs = __lit[__num_base::_S_odigits], ++__len;
     else
       {

  const bool __uppercase = __flags & ios_base::uppercase;
  *--__cs = __lit[__num_base::_S_ox + __uppercase];

  *--__cs = __lit[__num_base::_S_odigits];
  __len += 2;
       }
   }


 const streamsize __w = __io.width();
 if (__w > static_cast<streamsize>(__len))
   {
     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __w));
     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
     __cs = __cs3;
   }
 __io.width(0);



 return std::__write(__s, __cs, __len);
      }

  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_float(const char* __grouping, size_t __grouping_size,
     _CharT __sep, const _CharT* __p, _CharT* __new,
     _CharT* __cs, int& __len) const
    {



      const int __declen = __p ? __p - __cs : __len;
      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
      __grouping_size,
      __cs, __cs + __declen);


      int __newlen = __p2 - __new;
      if (__p)
 {
   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
   __newlen += __len - __declen;
 }
      __len = __newlen;
    }
# 966 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
         _ValueT __v) const
      {
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);


 const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();

 const int __max_digits =
   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;


 int __len;

 char __fbuf[16];
 __num_base::_S_format_float(__io, __fbuf, __mod);




 int __cs_size = __max_digits * 3;
 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
          __fbuf, __prec, __v);


 if (__len >= __cs_size)
   {
     __cs_size = __len + 1;
     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
     __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
       __fbuf, __prec, __v);
   }
# 1027 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
            * __len));
 __ctype.widen(__cs, __cs + __len, __ws);


 _CharT* __wp = 0;
 const char* __p = char_traits<char>::find(__cs, __len, '.');
 if (__p)
   {
     __wp = __ws + (__p - __cs);
     *__wp = __lc->_M_decimal_point;
   }




 if (__lc->_M_use_grouping
     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
          && __cs[1] >= '0' && __cs[2] >= '0')))
   {


     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __len * 2));

     streamsize __off = 0;
     if (__cs[0] == '-' || __cs[0] == '+')
       {
  __off = 1;
  __ws2[0] = __ws[0];
  __len -= 1;
       }

     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
      __lc->_M_thousands_sep, __wp, __ws2 + __off,
      __ws + __off, __len);
     __len += __off;

     __ws = __ws2;
   }


 const streamsize __w = __io.width();
 if (__w > static_cast<streamsize>(__len))
   {
     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __w));
     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
     __ws = __ws3;
   }
 __io.width(0);



 return std::__write(__s, __ws, __len);
      }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
    {
      const ios_base::fmtflags __flags = __io.flags();
      if ((__flags & ios_base::boolalpha) == 0)
        {
          const long __l = __v;
          __s = _M_insert_int(__s, __io, __fill, __l);
        }
      else
        {
   typedef __numpunct_cache<_CharT> __cache_type;
   __use_cache<__cache_type> __uc;
   const locale& __loc = __io._M_getloc();
   const __cache_type* __lc = __uc(__loc);

   const _CharT* __name = __v ? __lc->_M_truename
                              : __lc->_M_falsename;
   int __len = __v ? __lc->_M_truename_size
                   : __lc->_M_falsename_size;

   const streamsize __w = __io.width();
   if (__w > static_cast<streamsize>(__len))
     {
       const streamsize __plen = __w - __len;
       _CharT* __ps
  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
       * __plen));

       char_traits<_CharT>::assign(__ps, __plen, __fill);
       __io.width(0);

       if ((__flags & ios_base::adjustfield) == ios_base::left)
  {
    __s = std::__write(__s, __name, __len);
    __s = std::__write(__s, __ps, __plen);
  }
       else
  {
    __s = std::__write(__s, __ps, __plen);
    __s = std::__write(__s, __name, __len);
  }
       return __s;
     }
   __io.width(0);
   __s = std::__write(__s, __name, __len);
 }
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
    { return _M_insert_float(__s, __io, __fill, char(), __v); }
# 1152 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
    long double __v) const
    { return _M_insert_float(__s, __io, __fill, 'L', __v); }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           const void* __v) const
    {
      const ios_base::fmtflags __flags = __io.flags();
      const ios_base::fmtflags __fmt = ~(ios_base::basefield
      | ios_base::uppercase);
      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));

      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
          <= sizeof(unsigned long)),
 unsigned long, unsigned long long>::__type _UIntPtrType;

      __s = _M_insert_int(__s, __io, __fill,
     reinterpret_cast<_UIntPtrType>(__v));
      __io.flags(__flags);
      return __s;
    }


# 1189 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _Traits>
    void
    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
       _CharT* __news, const _CharT* __olds,
       streamsize __newlen, streamsize __oldlen)
    {
      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;


      if (__adjust == ios_base::left)
 {
   _Traits::copy(__news, __olds, __oldlen);
   _Traits::assign(__news + __oldlen, __plen, __fill);
   return;
 }

      size_t __mod = 0;
      if (__adjust == ios_base::internal)
 {



          const locale& __loc = __io._M_getloc();
   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

   if (__ctype.widen('-') == __olds[0]
       || __ctype.widen('+') == __olds[0])
     {
       __news[0] = __olds[0];
       __mod = 1;
       ++__news;
     }
   else if (__ctype.widen('0') == __olds[0]
     && __oldlen > 1
     && (__ctype.widen('x') == __olds[1]
         || __ctype.widen('X') == __olds[1]))
     {
       __news[0] = __olds[0];
       __news[1] = __olds[1];
       __mod = 2;
       __news += 2;
     }

 }
      _Traits::assign(__news, __plen, __fill);
      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
    }

  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last)
    {
      size_t __idx = 0;
      size_t __ctr = 0;

      while (__last - __first > __gbeg[__idx]
      && static_cast<signed char>(__gbeg[__idx]) > 0
      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
 {
   __last -= __gbeg[__idx];
   __idx < __gsize - 1 ? ++__idx : ++__ctr;
 }

      while (__first != __last)
 *__s++ = *__first++;

      while (__ctr--)
 {
   *__s++ = __sep;
   for (char __i = __gbeg[__idx]; __i > 0; --__i)
     *__s++ = *__first++;
 }

      while (__idx--)
 {
   *__s++ = __sep;
   for (char __i = __gbeg[__idx]; __i > 0; --__i)
     *__s++ = *__first++;
 }

      return __s;
    }





  extern template class numpunct<char>;
  extern template class numpunct_byname<char>;
  extern template class num_get<char>;
  extern template class num_put<char>;
  extern template class ctype_byname<char>;

  extern template
    const ctype<char>&
    use_facet<ctype<char> >(const locale&);

  extern template
    const numpunct<char>&
    use_facet<numpunct<char> >(const locale&);

  extern template
    const num_put<char>&
    use_facet<num_put<char> >(const locale&);

  extern template
    const num_get<char>&
    use_facet<num_get<char> >(const locale&);

  extern template
    bool
    has_facet<ctype<char> >(const locale&);

  extern template
    bool
    has_facet<numpunct<char> >(const locale&);

  extern template
    bool
    has_facet<num_put<char> >(const locale&);

  extern template
    bool
    has_facet<num_get<char> >(const locale&);


  extern template class numpunct<wchar_t>;
  extern template class numpunct_byname<wchar_t>;
  extern template class num_get<wchar_t>;
  extern template class num_put<wchar_t>;
  extern template class ctype_byname<wchar_t>;

  extern template
    const ctype<wchar_t>&
    use_facet<ctype<wchar_t> >(const locale&);

  extern template
    const numpunct<wchar_t>&
    use_facet<numpunct<wchar_t> >(const locale&);

  extern template
    const num_put<wchar_t>&
    use_facet<num_put<wchar_t> >(const locale&);

  extern template
    const num_get<wchar_t>&
    use_facet<num_get<wchar_t> >(const locale&);

 extern template
    bool
    has_facet<ctype<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<numpunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_get<wchar_t> >(const locale&);



}
# 2602 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 2 3


namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _Facet>
    inline const _Facet&
    __check_facet(const _Facet* __f)
    {
      if (!__f)
 __throw_bad_cast();
      return *__f;
    }
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
  template<typename _CharT, typename _Traits>
    class basic_ios : public ios_base
    {
    public:






      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;






      typedef ctype<_CharT> __ctype_type;
      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
           __num_put_type;
      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
           __num_get_type;



    public:
      basic_ostream<_CharT, _Traits>* _M_tie;
      mutable char_type _M_fill;
      mutable bool _M_fill_init;
      basic_streambuf<_CharT, _Traits>* _M_streambuf;


      const __ctype_type* _M_ctype;

      const __num_put_type* _M_num_put;

      const __num_get_type* _M_num_get;

    public:







      operator void*() const
      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }

      bool
      operator!() const
      { return this->fail(); }
# 126 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      iostate
      rdstate() const
      { return _M_streambuf_state; }
# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      void
      clear(iostate __state = goodbit);







      void
      setstate(iostate __state)
      { this->clear(this->rdstate() | __state); }




      void
      _M_setstate(iostate __state)
      {


 _M_streambuf_state |= __state;
 if (this->exceptions() & __state)
   throw;
      }







      bool
      good() const
      { return this->rdstate() == 0; }







      bool
      eof() const
      { return (this->rdstate() & eofbit) != 0; }
# 190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }







      bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }
# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      iostate
      exceptions() const
      { return _M_exception; }
# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      void
      exceptions(iostate __except)
      {
        _M_exception = __except;
        this->clear(_M_streambuf_state);
      }







      explicit
      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
 _M_ctype(0), _M_num_put(0), _M_num_get(0)
      { this->init(__sb); }







      virtual
      ~basic_ios() { }
# 284 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }
# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie(basic_ostream<_CharT, _Traits>* __tiestr)
      {
        basic_ostream<_CharT, _Traits>* __old = _M_tie;
        _M_tie = __tiestr;
        return __old;
      }







      basic_streambuf<_CharT, _Traits>*
      rdbuf() const
      { return _M_streambuf; }
# 336 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
# 350 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      basic_ios&
      copyfmt(const basic_ios& __rhs);







      char_type
      fill() const
      {
 if (!_M_fill_init)
   {
     _M_fill = this->widen(' ');
     _M_fill_init = true;
   }
 return _M_fill;
      }
# 379 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      char_type
      fill(char_type __ch)
      {
 char_type __old = this->fill();
 _M_fill = __ch;
 return __old;
      }
# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      locale
      imbue(const locale& __loc);
# 419 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
      char_type
      widen(char __c) const
      { return __check_facet(_M_ctype).widen(__c); }

    public:







      basic_ios()
      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
 _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
      { }







      void
      init(basic_streambuf<_CharT, _Traits>* __sb);

      void
      _M_cache_locale(const locale& __loc);
    };

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.tcc" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.tcc" 3
       
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.tcc" 3

namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::clear(iostate __state)
    {
      if (this->rdbuf())
 _M_streambuf_state = __state;
      else
   _M_streambuf_state = __state | badbit;
      if (this->exceptions() & this->rdstate())
 __throw_ios_failure(("basic_ios::clear"));
    }

  template<typename _CharT, typename _Traits>
    basic_streambuf<_CharT, _Traits>*
    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
    {
      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
      _M_streambuf = __sb;
      this->clear();
      return __old;
    }

  template<typename _CharT, typename _Traits>
    basic_ios<_CharT, _Traits>&
    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
    {


      if (this != &__rhs)
 {




   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
                      _M_local_word : new _Words[__rhs._M_word_size];


   _Callback_list* __cb = __rhs._M_callbacks;
   if (__cb)
     __cb->_M_add_reference();
   _M_call_callbacks(erase_event);
   if (_M_word != _M_local_word)
     {
       delete [] _M_word;
       _M_word = 0;
     }
   _M_dispose_callbacks();


   _M_callbacks = __cb;
   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
     __words[__i] = __rhs._M_word[__i];
   _M_word = __words;
   _M_word_size = __rhs._M_word_size;

   this->flags(__rhs.flags());
   this->width(__rhs.width());
   this->precision(__rhs.precision());
   this->tie(__rhs.tie());
   this->fill(__rhs.fill());
   _M_ios_locale = __rhs.getloc();
   _M_cache_locale(_M_ios_locale);

   _M_call_callbacks(copyfmt_event);


   this->exceptions(__rhs.exceptions());
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    locale
    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
    {
      locale __old(this->getloc());
      ios_base::imbue(__loc);
      _M_cache_locale(__loc);
      if (this->rdbuf() != 0)
 this->rdbuf()->pubimbue(__loc);
      return __old;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
    {

      ios_base::_M_init();


      _M_cache_locale(_M_ios_locale);
# 145 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.tcc" 3
      _M_fill = _CharT();
      _M_fill_init = false;

      _M_tie = 0;
      _M_exception = goodbit;
      _M_streambuf = __sb;
      _M_streambuf_state = __sb ? goodbit : badbit;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
    {
      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
 _M_ctype = &use_facet<__ctype_type>(__loc);
      else
 _M_ctype = 0;

      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
 _M_num_put = &use_facet<__num_put_type>(__loc);
      else
 _M_num_put = 0;

      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
 _M_num_get = &use_facet<__num_get_type>(__loc);
      else
 _M_num_get = 0;
    }





  extern template class basic_ios<char>;


  extern template class basic_ios<wchar_t>;



}
# 472 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 2 3
# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 2 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 2 3


namespace std __attribute__ ((__visibility__ ("default"))) {
# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
  template<typename _CharT, typename _Traits>
    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
             __num_put_type;
      typedef ctype<_CharT> __ctype_type;
# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }






      virtual
      ~basic_ostream() { }


      class sentry;
      friend class sentry;
# 107 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      __ostream_type&
      operator<<(__ostream_type& (*__pf)(__ostream_type&))
      {



 return __pf(*this);
      }

      __ostream_type&
      operator<<(__ios_type& (*__pf)(__ios_type&))
      {



 __pf(*this);
 return *this;
      }

      __ostream_type&
      operator<<(ios_base& (*__pf) (ios_base&))
      {



 __pf(*this);
 return *this;
      }
# 164 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      __ostream_type&
      operator<<(long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(unsigned long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(bool __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(short __n);

      __ostream_type&
      operator<<(unsigned short __n)
      {


 return _M_insert(static_cast<unsigned long>(__n));
      }

      __ostream_type&
      operator<<(int __n);

      __ostream_type&
      operator<<(unsigned int __n)
      {


 return _M_insert(static_cast<unsigned long>(__n));
      }


      __ostream_type&
      operator<<(long long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(unsigned long long __n)
      { return _M_insert(__n); }


      __ostream_type&
      operator<<(double __f)
      { return _M_insert(__f); }

      __ostream_type&
      operator<<(float __f)
      {


 return _M_insert(static_cast<double>(__f));
      }

      __ostream_type&
      operator<<(long double __f)
      { return _M_insert(__f); }

      __ostream_type&
      operator<<(const void* __p)
      { return _M_insert(__p); }
# 249 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      __ostream_type&
      operator<<(__streambuf_type* __sb);
# 282 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      __ostream_type&
      put(char_type __c);


      void
      _M_write(const char_type* __s, streamsize __n)
      {
 const streamsize __put = this->rdbuf()->sputn(__s, __n);
 if (__put != __n)
   this->setstate(ios_base::badbit);
      }
# 310 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      __ostream_type&
      write(const char_type* __s, streamsize __n);
# 323 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      __ostream_type&
      flush();
# 334 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      pos_type
      tellp();
# 345 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      __ostream_type&
      seekp(pos_type);
# 357 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
       __ostream_type&
      seekp(off_type, ios_base::seekdir);

    public:
      basic_ostream()
      { this->init(0); }

      template<typename _ValueT>
        __ostream_type&
        _M_insert(_ValueT __v);
    };
# 376 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

      bool _M_ok;
      basic_ostream<_CharT, _Traits>& _M_os;

    public:
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      explicit
      sentry(basic_ostream<_CharT, _Traits>& __os);
# 405 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      ~sentry()
      {

 if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
   {

     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
       _M_os.setstate(ios_base::badbit);
   }
      }
# 426 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
      operator bool() const
      { return _M_ok; }
    };
# 447 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
    { return __ostream_insert(__out, &__c, 1); }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
    { return (__out << __out.widen(__c)); }


  template <class _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c)
    { return __ostream_insert(__out, &__c, 1); }


  template<class _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
    { return (__out << static_cast<char>(__c)); }

  template<class _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
    { return (__out << static_cast<char>(__c)); }
# 489 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 __ostream_insert(__out, __s,
    static_cast<streamsize>(_Traits::length(__s)));
      return __out;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits> &
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);


  template<class _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 __ostream_insert(__out, __s,
    static_cast<streamsize>(_Traits::length(__s)));
      return __out;
    }


  template<class _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }

  template<class _Traits>
    inline basic_ostream<char, _Traits> &
    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }
# 539 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    endl(basic_ostream<_CharT, _Traits>& __os)
    { return flush(__os.put(__os.widen('\n'))); }







  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    ends(basic_ostream<_CharT, _Traits>& __os)
    { return __os.put(_CharT()); }






  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    flush(basic_ostream<_CharT, _Traits>& __os)
    { return __os.flush(); }
# 583 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream.tcc" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream.tcc" 3
       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream.tcc" 3



namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>::sentry::
    sentry(basic_ostream<_CharT, _Traits>& __os)
    : _M_ok(false), _M_os(__os)
    {

      if (__os.tie() && __os.good())
 __os.tie()->flush();

      if (__os.good())
 _M_ok = true;
      else
 __os.setstate(ios_base::failbit);
    }

  template<typename _CharT, typename _Traits>
    template<typename _ValueT>
      basic_ostream<_CharT, _Traits>&
      basic_ostream<_CharT, _Traits>::
      _M_insert(_ValueT __v)
      {
 sentry __cerb(*this);
 if (__cerb)
   {
     ios_base::iostate __err = ios_base::goodbit;
     try
       {
  const __num_put_type& __np = __check_facet(this->_M_num_put);
  if (__np.put(*this, *this, this->fill(), __v).failed())
    __err |= ios_base::badbit;
       }
     catch(__cxxabiv1::__forced_unwind&)
       {
  this->_M_setstate(ios_base::badbit);
  throw;
       }
     catch(...)
       { this->_M_setstate(ios_base::badbit); }
     if (__err)
       this->setstate(__err);
   }
 return *this;
      }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(short __n)
    {


      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
      else
 return _M_insert(static_cast<long>(__n));
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(int __n)
    {


      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
      else
 return _M_insert(static_cast<long>(__n));
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__streambuf_type* __sbin)
    {
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this);
      if (__cerb && __sbin)
 {
   try
     {
       if (!__copy_streambufs(__sbin, this->rdbuf()))
  __err |= ios_base::failbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbin)
 __err |= ios_base::badbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    put(char_type __c)
    {






      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __put = this->rdbuf()->sputc(__c);
       if (traits_type::eq_int_type(__put, traits_type::eof()))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    write(const _CharT* __s, streamsize __n)
    {







      sentry __cerb(*this);
      if (__cerb)
 {
   try
     { _M_write(__s, __n); }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    flush()
    {



      ios_base::iostate __err = ios_base::goodbit;
      try
 {
   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
     __err |= ios_base::badbit;
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_ostream<_CharT, _Traits>::pos_type
    basic_ostream<_CharT, _Traits>::
    tellp()
    {
      pos_type __ret = pos_type(-1);
      try
 {
   if (!this->fail())
     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(pos_type __pos)
    {
      ios_base::iostate __err = ios_base::goodbit;
      try
 {
   if (!this->fail())
     {


       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
            ios_base::out);


       if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;
     }
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(off_type __off, ios_base::seekdir __dir)
    {
      ios_base::iostate __err = ios_base::goodbit;
      try
 {
   if (!this->fail())
     {


       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
            ios_base::out);


       if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;
     }
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 {


   const size_t __clen = char_traits<char>::length(__s);
   try
     {
       struct __ptr_guard
       {
  _CharT *__p;
  __ptr_guard (_CharT *__ip): __p(__ip) { }
  ~__ptr_guard() { delete[] __p; }
  _CharT* __get() { return __p; }
       } __pg (new _CharT[__clen]);

       _CharT *__ws = __pg.__get();
       for (size_t __i = 0; __i < __clen; ++__i)
  __ws[__i] = __out.widen(__s[__i]);
       __ostream_insert(__out, __ws, __clen);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __out._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      return __out;
    }





  extern template class basic_ostream<char>;
  extern template ostream& endl(ostream&);
  extern template ostream& ends(ostream&);
  extern template ostream& flush(ostream&);
  extern template ostream& operator<<(ostream&, char);
  extern template ostream& operator<<(ostream&, unsigned char);
  extern template ostream& operator<<(ostream&, signed char);
  extern template ostream& operator<<(ostream&, const char*);
  extern template ostream& operator<<(ostream&, const unsigned char*);
  extern template ostream& operator<<(ostream&, const signed char*);

  extern template ostream& ostream::_M_insert(long);
  extern template ostream& ostream::_M_insert(unsigned long);
  extern template ostream& ostream::_M_insert(bool);

  extern template ostream& ostream::_M_insert(long long);
  extern template ostream& ostream::_M_insert(unsigned long long);

  extern template ostream& ostream::_M_insert(double);
  extern template ostream& ostream::_M_insert(long double);
  extern template ostream& ostream::_M_insert(const void*);


  extern template class basic_ostream<wchar_t>;
  extern template wostream& endl(wostream&);
  extern template wostream& ends(wostream&);
  extern template wostream& flush(wostream&);
  extern template wostream& operator<<(wostream&, wchar_t);
  extern template wostream& operator<<(wostream&, char);
  extern template wostream& operator<<(wostream&, const wchar_t*);
  extern template wostream& operator<<(wostream&, const char*);

  extern template wostream& wostream::_M_insert(long);
  extern template wostream& wostream::_M_insert(unsigned long);
  extern template wostream& wostream::_M_insert(bool);

  extern template wostream& wostream::_M_insert(long long);
  extern template wostream& wostream::_M_insert(unsigned long long);

  extern template wostream& wostream::_M_insert(double);
  extern template wostream& wostream::_M_insert(long double);
  extern template wostream& wostream::_M_insert(const void*);



}
# 587 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 2 3
# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3




namespace std __attribute__ ((__visibility__ ("default"))) {
# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_istream : virtual public basic_ios<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
        __num_get_type;
      typedef ctype<_CharT> __ctype_type;

    public:





      streamsize _M_gcount;

    public:
# 90 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      explicit
      basic_istream(__streambuf_type* __sb)
      : _M_gcount(streamsize(0))
      { this->init(__sb); }






      virtual
      ~basic_istream()
      { _M_gcount = streamsize(0); }


      class sentry;
      friend class sentry;
# 119 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      operator>>(__istream_type& (*__pf)(__istream_type&))
      { return __pf(*this); }

      __istream_type&
      operator>>(__ios_type& (*__pf)(__ios_type&))
      {
 __pf(*this);
 return *this;
      }

      __istream_type&
      operator>>(ios_base& (*__pf)(ios_base&))
      {
 __pf(*this);
 return *this;
      }
# 166 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      operator>>(bool& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(short& __n);

      __istream_type&
      operator>>(unsigned short& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(int& __n);

      __istream_type&
      operator>>(unsigned int& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(long& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(unsigned long& __n)
      { return _M_extract(__n); }


      __istream_type&
      operator>>(long long& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(unsigned long long& __n)
      { return _M_extract(__n); }


      __istream_type&
      operator>>(float& __f)
      { return _M_extract(__f); }

      __istream_type&
      operator>>(double& __f)
      { return _M_extract(__f); }

      __istream_type&
      operator>>(long double& __f)
      { return _M_extract(__f); }

      __istream_type&
      operator>>(void*& __p)
      { return _M_extract(__p); }
# 238 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      operator>>(__streambuf_type* __sb);
# 248 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      streamsize
      gcount() const
      { return _M_gcount; }
# 280 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      int_type
      get();
# 294 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      get(char_type& __c);
# 321 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);
# 332 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n)
      { return this->get(__s, __n, this->widen('\n')); }
# 355 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);
# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      get(__streambuf_type& __sb)
      { return this->get(__sb, this->widen('\n')); }
# 394 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);
# 405 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n)
      { return this->getline(__s, __n, this->widen('\n')); }
# 429 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      ignore();

      __istream_type&
      ignore(streamsize __n);

      __istream_type&
      ignore(streamsize __n, int_type __delim);
# 446 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      int_type
      peek();
# 464 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      read(char_type* __s, streamsize __n);
# 483 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      streamsize
      readsome(char_type* __s, streamsize __n);
# 499 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      putback(char_type __c);
# 514 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      unget();
# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      int
      sync();
# 546 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      pos_type
      tellg();
# 561 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      seekg(pos_type);
# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      __istream_type&
      seekg(off_type, ios_base::seekdir);


    public:
      basic_istream()
      : _M_gcount(streamsize(0))
      { this->init(0); }

      template<typename _ValueT>
        __istream_type&
        _M_extract(_ValueT& __v);
    };


  template<>
    basic_istream<char>&
    basic_istream<char>::
    getline(char_type* __s, streamsize __n, char_type __delim);

  template<>
    basic_istream<char>&
    basic_istream<char>::
    ignore(streamsize __n);

  template<>
    basic_istream<char>&
    basic_istream<char>::
    ignore(streamsize __n, int_type __delim);


  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    getline(char_type* __s, streamsize __n, char_type __delim);

  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    ignore(streamsize __n);

  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    ignore(streamsize __n, int_type __delim);
# 632 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_istream<_CharT, _Traits>::sentry
    {

      bool _M_ok;

    public:

      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef typename _Traits::int_type __int_type;
# 668 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
# 681 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
      operator bool() const
      { return _M_ok; }
    };
# 698 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }
# 740 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);


  template<>
    basic_istream<char>&
    operator>>(basic_istream<char>& __in, char* __s);

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }
# 768 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_iostream
    : public basic_istream<_CharT, _Traits>,
      public basic_ostream<_CharT, _Traits>
    {
    public:



      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;







      explicit
      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
      : __istream_type(__sb), __ostream_type(__sb) { }




      virtual
      ~basic_iostream() { }

    public:
      basic_iostream()
      : __istream_type(), __ostream_type() { }
    };
# 829 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);
# 851 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/istream.tcc" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/istream.tcc" 3
       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/istream.tcc" 3



namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>::sentry::
    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
    {
      ios_base::iostate __err = ios_base::goodbit;
      if (__in.good())
 {
   if (__in.tie())
     __in.tie()->flush();
   if (!__noskip && bool(__in.flags() & ios_base::skipws))
     {
       const __int_type __eof = traits_type::eof();
       __streambuf_type* __sb = __in.rdbuf();
       __int_type __c = __sb->sgetc();

       const __ctype_type& __ct = __check_facet(__in._M_ctype);
       while (!traits_type::eq_int_type(__c, __eof)
       && __ct.is(ctype_base::space,
    traits_type::to_char_type(__c)))
  __c = __sb->snextc();




       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
 }

      if (__in.good() && __err == ios_base::goodbit)
 _M_ok = true;
      else
 {
   __err |= ios_base::failbit;
   __in.setstate(__err);
 }
    }

  template<typename _CharT, typename _Traits>
    template<typename _ValueT>
      basic_istream<_CharT, _Traits>&
      basic_istream<_CharT, _Traits>::
      _M_extract(_ValueT& __v)
      {
 sentry __cerb(*this, false);
 if (__cerb)
   {
     ios_base::iostate __err = ios_base::goodbit;
     try
       {
  const __num_get_type& __ng = __check_facet(this->_M_num_get);
  __ng.get(*this, 0, *this, __err, __v);
       }
     catch(__cxxabiv1::__forced_unwind&)
       {
  this->_M_setstate(ios_base::badbit);
  throw;
       }
     catch(...)
       { this->_M_setstate(ios_base::badbit); }
     if (__err)
       this->setstate(__err);
   }
 return *this;
      }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(short& __n)
    {


      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       long __l;
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __l);



       if (__l < __gnu_cxx::__numeric_traits<short>::__min)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<short>::__min;
  }
       else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<short>::__max;
  }
       else
  __n = short(__l);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(int& __n)
    {


      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       long __l;
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __l);



       if (__l < __gnu_cxx::__numeric_traits<int>::__min)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<int>::__min;
  }
       else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<int>::__max;
  }
       else
  __n = int(__l);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__streambuf_type* __sbout)
    {
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, false);
      if (__cerb && __sbout)
 {
   try
     {
       bool __ineof;
       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
  __err |= ios_base::failbit;
       if (__ineof)
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::failbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbout)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    get(void)
    {
      const int_type __eof = traits_type::eof();
      int_type __c = __eof;
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       __c = this->rdbuf()->sbumpc();

       if (!traits_type::eq_int_type(__c, __eof))
  _M_gcount = 1;
       else
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type& __c)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __cb = this->rdbuf()->sbumpc();

       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
  {
    _M_gcount = 1;
    __c = traits_type::to_char_type(__cb);
  }
       else
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __idelim = traits_type::to_int_type(__delim);
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       int_type __c = __sb->sgetc();

       while (_M_gcount + 1 < __n
       && !traits_type::eq_int_type(__c, __eof)
       && !traits_type::eq_int_type(__c, __idelim))
  {
    *__s++ = traits_type::to_char_type(__c);
    ++_M_gcount;
    __c = __sb->snextc();
  }
       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }


      if (__n > 0)
 *__s = char_type();
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(__streambuf_type& __sb, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __idelim = traits_type::to_int_type(__delim);
       const int_type __eof = traits_type::eof();
       __streambuf_type* __this_sb = this->rdbuf();
       int_type __c = __this_sb->sgetc();
       char_type __c2 = traits_type::to_char_type(__c);

       while (!traits_type::eq_int_type(__c, __eof)
       && !traits_type::eq_int_type(__c, __idelim)
       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
  {
    ++_M_gcount;
    __c = __this_sb->snextc();
    __c2 = traits_type::to_char_type(__c);
  }
       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    getline(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();

              while (_M_gcount + 1 < __n
                     && !traits_type::eq_int_type(__c, __eof)
                     && !traits_type::eq_int_type(__c, __idelim))
                {
                  *__s++ = traits_type::to_char_type(__c);
                  __c = __sb->snextc();
                  ++_M_gcount;
                }
              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
              else
                {
                  if (traits_type::eq_int_type(__c, __idelim))
                    {
                      __sb->sbumpc();
                      ++_M_gcount;
                    }
                  else
                    __err |= ios_base::failbit;
                }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
        }


      if (__n > 0)
 *__s = char_type();
      if (!_M_gcount)
        __err |= ios_base::failbit;
      if (__err)
        this->setstate(__err);
      return *this;
    }




  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(void)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();

       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
  __err |= ios_base::eofbit;
       else
  _M_gcount = 1;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();
# 513 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/istream.tcc" 3
       bool __large_ignore = false;
       while (true)
  {
    while (_M_gcount < __n
    && !traits_type::eq_int_type(__c, __eof))
      {
        ++_M_gcount;
        __c = __sb->snextc();
      }
    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
        && !traits_type::eq_int_type(__c, __eof))
      {
        _M_gcount =
   __gnu_cxx::__numeric_traits<streamsize>::__min;
        __large_ignore = true;
      }
    else
      break;
  }

       if (__large_ignore)
  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

       if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n, int_type __delim)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();


       bool __large_ignore = false;
       while (true)
  {
    while (_M_gcount < __n
    && !traits_type::eq_int_type(__c, __eof)
    && !traits_type::eq_int_type(__c, __delim))
      {
        ++_M_gcount;
        __c = __sb->snextc();
      }
    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
        && !traits_type::eq_int_type(__c, __eof)
        && !traits_type::eq_int_type(__c, __delim))
      {
        _M_gcount =
   __gnu_cxx::__numeric_traits<streamsize>::__min;
        __large_ignore = true;
      }
    else
      break;
  }

       if (__large_ignore)
  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
       else if (traits_type::eq_int_type(__c, __delim))
  {
    if (_M_gcount
        < __gnu_cxx::__numeric_traits<streamsize>::__max)
      ++_M_gcount;
    __sb->sbumpc();
  }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    peek(void)
    {
      int_type __c = traits_type::eof();
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       __c = this->rdbuf()->sgetc();
       if (traits_type::eq_int_type(__c, traits_type::eof()))
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    read(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       _M_gcount = this->rdbuf()->sgetn(__s, __n);
       if (_M_gcount != __n)
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_istream<_CharT, _Traits>::
    readsome(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {

       const streamsize __num = this->rdbuf()->in_avail();
       if (__num > 0)
  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
       else if (__num == -1)
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return _M_gcount;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    putback(char_type __c)
    {


      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       if (!__sb
    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    unget(void)
    {


      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       if (!__sb
    || traits_type::eq_int_type(__sb->sungetc(), __eof))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_istream<_CharT, _Traits>::
    sync(void)
    {


      int __ret = -1;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       __streambuf_type* __sb = this->rdbuf();
       if (__sb)
  {
    if (__sb->pubsync() == -1)
      __err |= ios_base::badbit;
    else
      __ret = 0;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::pos_type
    basic_istream<_CharT, _Traits>::
    tellg(void)
    {


      pos_type __ret = pos_type(-1);
      try
 {
   if (!this->fail())
     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
           ios_base::in);
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(pos_type __pos)
    {


      ios_base::iostate __err = ios_base::goodbit;
      try
 {
   if (!this->fail())
     {

       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
            ios_base::in);


       if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;
     }
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(off_type __off, ios_base::seekdir __dir)
    {


      ios_base::iostate __err = ios_base::goodbit;
      try
 {
   if (!this->fail())
     {

       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
            ios_base::in);


       if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;
     }
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;

      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const __int_type __cb = __in.rdbuf()->sbumpc();
       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
  __c = _Traits::to_char_type(__cb);
       else
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
   if (__err)
     __in.setstate(__err);
 }
      return __in;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef typename _Traits::int_type int_type;
      typedef _CharT char_type;
      typedef ctype<_CharT> __ctype_type;

      streamsize __extracted = 0;
      ios_base::iostate __err = ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       streamsize __num = __in.width();
       if (__num <= 0)
  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;

       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());

       const int_type __eof = _Traits::eof();
       __streambuf_type* __sb = __in.rdbuf();
       int_type __c = __sb->sgetc();

       while (__extracted < __num - 1
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(ctype_base::space,
     _Traits::to_char_type(__c)))
  {
    *__s++ = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __sb->snextc();
  }
       if (_Traits::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;



       *__s = char_type();
       __in.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
 }
      if (!__extracted)
 __err |= ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __in)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef typename __istream_type::int_type __int_type;
      typedef ctype<_CharT> __ctype_type;

      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
      const __int_type __eof = _Traits::eof();
      __streambuf_type* __sb = __in.rdbuf();
      __int_type __c = __sb->sgetc();

      while (!_Traits::eq_int_type(__c, __eof)
      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
 __c = __sb->snextc();

       if (_Traits::eq_int_type(__c, __eof))
  __in.setstate(ios_base::eofbit);
      return __in;
    }





  extern template class basic_istream<char>;
  extern template istream& ws(istream&);
  extern template istream& operator>>(istream&, char&);
  extern template istream& operator>>(istream&, char*);
  extern template istream& operator>>(istream&, unsigned char&);
  extern template istream& operator>>(istream&, signed char&);
  extern template istream& operator>>(istream&, unsigned char*);
  extern template istream& operator>>(istream&, signed char*);

  extern template istream& istream::_M_extract(unsigned short&);
  extern template istream& istream::_M_extract(unsigned int&);
  extern template istream& istream::_M_extract(long&);
  extern template istream& istream::_M_extract(unsigned long&);
  extern template istream& istream::_M_extract(bool&);

  extern template istream& istream::_M_extract(long long&);
  extern template istream& istream::_M_extract(unsigned long long&);

  extern template istream& istream::_M_extract(float&);
  extern template istream& istream::_M_extract(double&);
  extern template istream& istream::_M_extract(long double&);
  extern template istream& istream::_M_extract(void*&);

  extern template class basic_iostream<char>;


  extern template class basic_istream<wchar_t>;
  extern template wistream& ws(wistream&);
  extern template wistream& operator>>(wistream&, wchar_t&);
  extern template wistream& operator>>(wistream&, wchar_t*);

  extern template wistream& wistream::_M_extract(unsigned short&);
  extern template wistream& wistream::_M_extract(unsigned int&);
  extern template wistream& wistream::_M_extract(long&);
  extern template wistream& wistream::_M_extract(unsigned long&);
  extern template wistream& wistream::_M_extract(bool&);

  extern template wistream& wistream::_M_extract(long long&);
  extern template wistream& wistream::_M_extract(unsigned long long&);

  extern template wistream& wistream::_M_extract(float&);
  extern template wistream& wistream::_M_extract(double&);
  extern template wistream& wistream::_M_extract(long double&);
  extern template wistream& wistream::_M_extract(void*&);

  extern template class basic_iostream<wchar_t>;



}
# 855 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 2 3
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stream_iterator.h" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stream_iterator.h" 3
       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stream_iterator.h" 3



namespace std __attribute__ ((__visibility__ ("default"))) {







  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
    class istream_iterator
    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
    {
    public:
      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_istream<_CharT, _Traits> istream_type;

    private:
      istream_type* _M_stream;
      _Tp _M_value;
      bool _M_ok;

    public:

      istream_iterator()
      : _M_stream(0), _M_value(), _M_ok(false) {}


      istream_iterator(istream_type& __s)
      : _M_stream(&__s)
      { _M_read(); }

      istream_iterator(const istream_iterator& __obj)
      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
        _M_ok(__obj._M_ok)
      { }

      const _Tp&
      operator*() const
      {


                        ;
 return _M_value;
      }

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

      istream_iterator&
      operator++()
      {


                        ;
 _M_read();
 return *this;
      }

      istream_iterator
      operator++(int)
      {


                        ;
 istream_iterator __tmp = *this;
 _M_read();
 return __tmp;
      }

      bool
      _M_equal(const istream_iterator& __x) const
      { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }

    private:
      void
      _M_read()
      {
 _M_ok = (_M_stream && *_M_stream) ? true : false;
 if (_M_ok)
   {
     *_M_stream >> _M_value;
     _M_ok = *_M_stream ? true : false;
   }
      }
    };


  template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
    inline bool
    operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
    { return __x._M_equal(__y); }


  template <class _Tp, class _CharT, class _Traits, class _Dist>
    inline bool
    operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
    { return !__x._M_equal(__y); }
# 150 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stream_iterator.h" 3
  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT> >
    class ostream_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:


      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;


    private:
      ostream_type* _M_stream;
      const _CharT* _M_string;

    public:

      ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
# 181 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stream_iterator.h" 3
      ostream_iterator(ostream_type& __s, const _CharT* __c)
      : _M_stream(&__s), _M_string(__c) { }


      ostream_iterator(const ostream_iterator& __obj)
      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }



      ostream_iterator&
      operator=(const _Tp& __value)
      {


                        ;
 *_M_stream << __value;
 if (_M_string) *_M_stream << _M_string;
 return *this;
      }

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

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

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



}
# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 2 3
# 51 "/usr/include/qt4/QtCore/qlist.h" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/list" 1 3
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/list" 3
       
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/list" 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 1 3
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {







  struct _List_node_base
  {
    _List_node_base* _M_next;
    _List_node_base* _M_prev;

    static void
    swap(_List_node_base& __x, _List_node_base& __y) throw ();

    void
    _M_transfer(_List_node_base * const __first,
  _List_node_base * const __last) throw ();

    void
    _M_reverse() throw ();

    void
    _M_hook(_List_node_base * const __position) throw ();

    void
    _M_unhook() throw ();
  };


  template<typename _Tp>
    struct _List_node : public _List_node_base
    {

      _Tp _M_data;






    };






  template<typename _Tp>
    struct _List_iterator
    {
      typedef _List_iterator<_Tp> _Self;
      typedef _List_node<_Tp> _Node;

      typedef ptrdiff_t difference_type;
      typedef std::bidirectional_iterator_tag iterator_category;
      typedef _Tp value_type;
      typedef _Tp* pointer;
      typedef _Tp& reference;

      _List_iterator()
      : _M_node() { }

      explicit
      _List_iterator(_List_node_base* __x)
      : _M_node(__x) { }


      reference
      operator*() const
      { return static_cast<_Node*>(_M_node)->_M_data; }

      pointer
      operator->() const
      { return &static_cast<_Node*>(_M_node)->_M_data; }

      _Self&
      operator++()
      {
 _M_node = _M_node->_M_next;
 return *this;
      }

      _Self
      operator++(int)
      {
 _Self __tmp = *this;
 _M_node = _M_node->_M_next;
 return __tmp;
      }

      _Self&
      operator--()
      {
 _M_node = _M_node->_M_prev;
 return *this;
      }

      _Self
      operator--(int)
      {
 _Self __tmp = *this;
 _M_node = _M_node->_M_prev;
 return __tmp;
      }

      bool
      operator==(const _Self& __x) const
      { return _M_node == __x._M_node; }

      bool
      operator!=(const _Self& __x) const
      { return _M_node != __x._M_node; }


      _List_node_base* _M_node;
    };






  template<typename _Tp>
    struct _List_const_iterator
    {
      typedef _List_const_iterator<_Tp> _Self;
      typedef const _List_node<_Tp> _Node;
      typedef _List_iterator<_Tp> iterator;

      typedef ptrdiff_t difference_type;
      typedef std::bidirectional_iterator_tag iterator_category;
      typedef _Tp value_type;
      typedef const _Tp* pointer;
      typedef const _Tp& reference;

      _List_const_iterator()
      : _M_node() { }

      explicit
      _List_const_iterator(const _List_node_base* __x)
      : _M_node(__x) { }

      _List_const_iterator(const iterator& __x)
      : _M_node(__x._M_node) { }



      reference
      operator*() const
      { return static_cast<_Node*>(_M_node)->_M_data; }

      pointer
      operator->() const
      { return &static_cast<_Node*>(_M_node)->_M_data; }

      _Self&
      operator++()
      {
 _M_node = _M_node->_M_next;
 return *this;
      }

      _Self
      operator++(int)
      {
 _Self __tmp = *this;
 _M_node = _M_node->_M_next;
 return __tmp;
      }

      _Self&
      operator--()
      {
 _M_node = _M_node->_M_prev;
 return *this;
      }

      _Self
      operator--(int)
      {
 _Self __tmp = *this;
 _M_node = _M_node->_M_prev;
 return __tmp;
      }

      bool
      operator==(const _Self& __x) const
      { return _M_node == __x._M_node; }

      bool
      operator!=(const _Self& __x) const
      { return _M_node != __x._M_node; }


      const _List_node_base* _M_node;
    };

  template<typename _Val>
    inline bool
    operator==(const _List_iterator<_Val>& __x,
        const _List_const_iterator<_Val>& __y)
    { return __x._M_node == __y._M_node; }

  template<typename _Val>
    inline bool
    operator!=(const _List_iterator<_Val>& __x,
               const _List_const_iterator<_Val>& __y)
    { return __x._M_node != __y._M_node; }



  template<typename _Tp, typename _Alloc>
    class _List_base
    {
    public:
# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
        _Node_alloc_type;

      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;

      struct _List_impl
      : public _Node_alloc_type
      {
 _List_node_base _M_node;

 _List_impl()
 : _Node_alloc_type(), _M_node()
 { }

 _List_impl(const _Node_alloc_type& __a)
 : _Node_alloc_type(__a), _M_node()
 { }
      };

      _List_impl _M_impl;

      _List_node<_Tp>*
      _M_get_node()
      { return _M_impl._Node_alloc_type::allocate(1); }

      void
      _M_put_node(_List_node<_Tp>* __p)
      { _M_impl._Node_alloc_type::deallocate(__p, 1); }

  public:
      typedef _Alloc allocator_type;

      _Node_alloc_type&
      _M_get_Node_allocator()
      { return *static_cast<_Node_alloc_type*>(&this->_M_impl); }

      const _Node_alloc_type&
      _M_get_Node_allocator() const
      { return *static_cast<const _Node_alloc_type*>(&this->_M_impl); }

      _Tp_alloc_type
      _M_get_Tp_allocator() const
      { return _Tp_alloc_type(_M_get_Node_allocator()); }

      allocator_type
      get_allocator() const
      { return allocator_type(_M_get_Node_allocator()); }

      _List_base()
      : _M_impl()
      { _M_init(); }

      _List_base(const allocator_type& __a)
      : _M_impl(__a)
      { _M_init(); }
# 359 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      ~_List_base()
      { _M_clear(); }

      void
      _M_clear();

      void
      _M_init()
      {
        this->_M_impl._M_node._M_next = &this->_M_impl._M_node;
        this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;
      }
    };
# 416 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class list : public _List_base<_Tp, _Alloc>
    {

      typedef typename _Alloc::value_type _Alloc_value_type;
     
     

      typedef _List_base<_Tp, _Alloc> _Base;
      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;

    public:
      typedef _Tp value_type;
      typedef typename _Tp_alloc_type::pointer pointer;
      typedef typename _Tp_alloc_type::const_pointer const_pointer;
      typedef typename _Tp_alloc_type::reference reference;
      typedef typename _Tp_alloc_type::const_reference const_reference;
      typedef _List_iterator<_Tp> iterator;
      typedef _List_const_iterator<_Tp> const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

    public:


      typedef _List_node<_Tp> _Node;

      using _Base::_M_impl;
      using _Base::_M_put_node;
      using _Base::_M_get_node;
      using _Base::_M_get_Tp_allocator;
      using _Base::_M_get_Node_allocator;







      _Node*
      _M_create_node(const value_type& __x)
      {
 _Node* __p = this->_M_get_node();
 try
   {
     _M_get_Tp_allocator().construct(&__p->_M_data, __x);
   }
 catch(...)
   {
     _M_put_node(__p);
     throw;
   }
 return __p;
      }
# 493 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
    public:





      list()
      : _Base() { }





      explicit
      list(const allocator_type& __a)
      : _Base(__a) { }
# 518 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      explicit
      list(size_type __n, const value_type& __value = value_type(),
    const allocator_type& __a = allocator_type())
      : _Base(__a)
      { _M_fill_initialize(__n, __value); }
# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      list(const list& __x)
      : _Base(__x._M_get_Node_allocator())
      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
# 570 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      template<typename _InputIterator>
        list(_InputIterator __first, _InputIterator __last,
      const allocator_type& __a = allocator_type())
        : _Base(__a)
        {

   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_initialize_dispatch(__first, __last, _Integral());
 }
# 595 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      list&
      operator=(const list& __x);
# 641 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      template<typename _InputIterator>
        void
        assign(_InputIterator __first, _InputIterator __last)
        {

   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_assign_dispatch(__first, __last, _Integral());
 }
# 680 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      allocator_type
      get_allocator() const
      { return _Base::get_allocator(); }






      iterator
      begin()
      { return iterator(this->_M_impl._M_node._M_next); }






      const_iterator
      begin() const
      { return const_iterator(this->_M_impl._M_node._M_next); }






      iterator
      end()
      { return iterator(&this->_M_impl._M_node); }






      const_iterator
      end() const
      { return const_iterator(&this->_M_impl._M_node); }






      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()); }
# 799 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      bool
      empty() const
      { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }


      size_type
      size() const
      { return std::distance(begin(), end()); }


      size_type
      max_size() const
      { return _M_get_Node_allocator().max_size(); }
# 823 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      resize(size_type __new_size, value_type __x = value_type());






      reference
      front()
      { return *begin(); }





      const_reference
      front() const
      { return *begin(); }





      reference
      back()
      {
 iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }





      const_reference
      back() const
      {
 const_iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }
# 878 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      push_front(const value_type& __x)
      { this->_M_insert(begin(), __x); }
# 905 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      pop_front()
      { this->_M_erase(begin()); }
# 919 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      push_back(const value_type& __x)
      { this->_M_insert(end(), __x); }
# 945 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      pop_back()
      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
# 978 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 1027 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      insert(iterator __position, size_type __n, const value_type& __x)
      {
 list __tmp(__n, __x, _M_get_Node_allocator());
 splice(__position, __tmp);
      }
# 1047 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      template<typename _InputIterator>
        void
        insert(iterator __position, _InputIterator __first,
        _InputIterator __last)
        {
   list __tmp(__first, __last, _M_get_Node_allocator());
   splice(__position, __tmp);
 }
# 1071 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      iterator
      erase(iterator __position);
# 1092 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      iterator
      erase(iterator __first, iterator __last)
      {
 while (__first != __last)
   __first = erase(__first);
 return __last;
      }
# 1109 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      swap(list& __x)
      {
 _List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node);



 std::__alloc_swap<typename _Base::_Node_alloc_type>::
   _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator());
      }







      void
      clear()
      {
        _Base::_M_clear();
        _Base::_M_init();
      }
# 1145 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void



      splice(iterator __position, list& __x)

      {
 if (!__x.empty())
   {
     _M_check_equal_allocators(__x);

     this->_M_transfer(__position, __x.begin(), __x.end());
   }
      }
# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void



      splice(iterator __position, list& __x, iterator __i)

      {
 iterator __j = __i;
 ++__j;
 if (__position == __i || __position == __j)
   return;

 if (this != &__x)
   _M_check_equal_allocators(__x);

 this->_M_transfer(__position, __i, __j);
      }
# 1211 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void




      splice(iterator __position, list& __x, iterator __first,
      iterator __last)

      {
 if (__first != __last)
   {
     if (this != &__x)
       _M_check_equal_allocators(__x);

     this->_M_transfer(__position, __first, __last);
   }
      }
# 1246 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      remove(const _Tp& __value);
# 1260 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      template<typename _Predicate>
        void
        remove_if(_Predicate);
# 1274 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      unique();
# 1289 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      template<typename _BinaryPredicate>
        void
        unique(_BinaryPredicate);
# 1310 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      merge(list& __x);
# 1336 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      template<typename _StrictWeakOrdering>
        void
        merge(list&, _StrictWeakOrdering);







      void
      reverse()
      { this->_M_impl._M_node._M_reverse(); }







      void
      sort();







      template<typename _StrictWeakOrdering>
        void
        sort(_StrictWeakOrdering);

    public:






      template<typename _Integer>
        void
        _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
        { _M_fill_initialize(static_cast<size_type>(__n), __x); }


      template<typename _InputIterator>
        void
        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
          __false_type)
        {
   for (; __first != __last; ++__first)
     push_back(*__first);
 }



      void
      _M_fill_initialize(size_type __n, const value_type& __x)
      {
 for (; __n > 0; --__n)
   push_back(__x);
      }
# 1407 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      template<typename _Integer>
        void
        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
        { _M_fill_assign(__n, __val); }


      template<typename _InputIterator>
        void
        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
      __false_type);



      void
      _M_fill_assign(size_type __n, const value_type& __val);



      void
      _M_transfer(iterator __position, iterator __first, iterator __last)
      { __position._M_node->_M_transfer(__first._M_node, __last._M_node); }



      void
      _M_insert(iterator __position, const value_type& __x)
      {
        _Node* __tmp = _M_create_node(__x);
        __tmp->_M_hook(__position._M_node);
      }
# 1448 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
      void
      _M_erase(iterator __position)
      {
        __position._M_node->_M_unhook();
        _Node* __n = static_cast<_Node*>(__position._M_node);



 _M_get_Tp_allocator().destroy(&__n->_M_data);

        _M_put_node(__n);
      }


      void
      _M_check_equal_allocators(list& __x)
      {
 if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
     _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
   __throw_runtime_error(("list::_M_check_equal_allocators"));
      }
    };
# 1481 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    {
      typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
      const_iterator __end1 = __x.end();
      const_iterator __end2 = __y.end();

      const_iterator __i1 = __x.begin();
      const_iterator __i2 = __y.begin();
      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
 {
   ++__i1;
   ++__i2;
 }
      return __i1 == __end1 && __i2 == __end2;
    }
# 1510 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    { return std::lexicographical_compare(__x.begin(), __x.end(),
       __y.begin(), __y.end()); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Tp, typename _Alloc>
    inline void
    swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
    { __x.swap(__y); }

}
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/list" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/list.tcc" 1 3
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/list.tcc" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _Tp, typename _Alloc>
    void
    _List_base<_Tp, _Alloc>::
    _M_clear()
    {
      typedef _List_node<_Tp> _Node;
      _Node* __cur = static_cast<_Node*>(this->_M_impl._M_node._M_next);
      while (__cur != &this->_M_impl._M_node)
 {
   _Node* __tmp = __cur;
   __cur = static_cast<_Node*>(__cur->_M_next);



   _M_get_Tp_allocator().destroy(&__tmp->_M_data);

   _M_put_node(__tmp);
 }
    }
# 95 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/list.tcc" 3
  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::iterator
    list<_Tp, _Alloc>::
    insert(iterator __position, const value_type& __x)
    {
      _Node* __tmp = _M_create_node(__x);
      __tmp->_M_hook(__position._M_node);
      return iterator(__tmp);
    }

  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::iterator
    list<_Tp, _Alloc>::
    erase(iterator __position)
    {
      iterator __ret = iterator(__position._M_node->_M_next);
      _M_erase(__position);
      return __ret;
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    resize(size_type __new_size, value_type __x)
    {
      iterator __i = begin();
      size_type __len = 0;
      for (; __i != end() && __len < __new_size; ++__i, ++__len)
        ;
      if (__len == __new_size)
        erase(__i, end());
      else
        insert(end(), __new_size - __len, __x);
    }

  template<typename _Tp, typename _Alloc>
    list<_Tp, _Alloc>&
    list<_Tp, _Alloc>::
    operator=(const list& __x)
    {
      if (this != &__x)
 {
   iterator __first1 = begin();
   iterator __last1 = end();
   const_iterator __first2 = __x.begin();
   const_iterator __last2 = __x.end();
   for (; __first1 != __last1 && __first2 != __last2;
        ++__first1, ++__first2)
     *__first1 = *__first2;
   if (__first2 == __last2)
     erase(__first1, __last1);
   else
     insert(__last1, __first2, __last2);
 }
      return *this;
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    _M_fill_assign(size_type __n, const value_type& __val)
    {
      iterator __i = begin();
      for (; __i != end() && __n > 0; ++__i, --__n)
        *__i = __val;
      if (__n > 0)
        insert(end(), __n, __val);
      else
        erase(__i, end());
    }

  template<typename _Tp, typename _Alloc>
    template <typename _InputIterator>
      void
      list<_Tp, _Alloc>::
      _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
    __false_type)
      {
        iterator __first1 = begin();
        iterator __last1 = end();
        for (; __first1 != __last1 && __first2 != __last2;
      ++__first1, ++__first2)
          *__first1 = *__first2;
        if (__first2 == __last2)
          erase(__first1, __last1);
        else
          insert(__last1, __first2, __last2);
      }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    remove(const value_type& __value)
    {
      iterator __first = begin();
      iterator __last = end();
      iterator __extra = __last;
      while (__first != __last)
 {
   iterator __next = __first;
   ++__next;
   if (*__first == __value)
     {



       if (&*__first != &__value)
  _M_erase(__first);
       else
  __extra = __first;
     }
   __first = __next;
 }
      if (__extra != __last)
 _M_erase(__extra);
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    unique()
    {
      iterator __first = begin();
      iterator __last = end();
      if (__first == __last)
 return;
      iterator __next = __first;
      while (++__next != __last)
 {
   if (*__first == *__next)
     _M_erase(__next);
   else
     __first = __next;
   __next = __first;
 }
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::



    merge(list& __x)

    {


      if (this != &__x)
 {
   _M_check_equal_allocators(__x);

   iterator __first1 = begin();
   iterator __last1 = end();
   iterator __first2 = __x.begin();
   iterator __last2 = __x.end();
   while (__first1 != __last1 && __first2 != __last2)
     if (*__first2 < *__first1)
       {
  iterator __next = __first2;
  _M_transfer(__first1, __first2, ++__next);
  __first2 = __next;
       }
     else
       ++__first1;
   if (__first2 != __last2)
     _M_transfer(__last1, __first2, __last2);
 }
    }

  template<typename _Tp, typename _Alloc>
    template <typename _StrictWeakOrdering>
      void
      list<_Tp, _Alloc>::



      merge(list& __x, _StrictWeakOrdering __comp)

      {


 if (this != &__x)
   {
     _M_check_equal_allocators(__x);

     iterator __first1 = begin();
     iterator __last1 = end();
     iterator __first2 = __x.begin();
     iterator __last2 = __x.end();
     while (__first1 != __last1 && __first2 != __last2)
       if (__comp(*__first2, *__first1))
  {
    iterator __next = __first2;
    _M_transfer(__first1, __first2, ++__next);
    __first2 = __next;
  }
       else
  ++__first1;
     if (__first2 != __last2)
       _M_transfer(__last1, __first2, __last2);
   }
      }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    sort()
    {

      if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
   && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
      {
        list __carry;
        list __tmp[64];
        list * __fill = &__tmp[0];
        list * __counter;

        do
   {
     __carry.splice(__carry.begin(), *this, begin());

     for(__counter = &__tmp[0];
  __counter != __fill && !__counter->empty();
  ++__counter)
       {
  __counter->merge(__carry);
  __carry.swap(*__counter);
       }
     __carry.swap(*__counter);
     if (__counter == __fill)
       ++__fill;
   }
 while ( !empty() );

        for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
          __counter->merge(*(__counter - 1));
        swap( *(__fill - 1) );
      }
    }

  template<typename _Tp, typename _Alloc>
    template <typename _Predicate>
      void
      list<_Tp, _Alloc>::
      remove_if(_Predicate __pred)
      {
        iterator __first = begin();
        iterator __last = end();
        while (__first != __last)
   {
     iterator __next = __first;
     ++__next;
     if (__pred(*__first))
       _M_erase(__first);
     __first = __next;
   }
      }

  template<typename _Tp, typename _Alloc>
    template <typename _BinaryPredicate>
      void
      list<_Tp, _Alloc>::
      unique(_BinaryPredicate __binary_pred)
      {
        iterator __first = begin();
        iterator __last = end();
        if (__first == __last)
   return;
        iterator __next = __first;
        while (++__next != __last)
   {
     if (__binary_pred(*__first, *__next))
       _M_erase(__next);
     else
       __first = __next;
     __next = __first;
   }
      }

  template<typename _Tp, typename _Alloc>
    template <typename _StrictWeakOrdering>
      void
      list<_Tp, _Alloc>::
      sort(_StrictWeakOrdering __comp)
      {

 if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
     && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
   {
     list __carry;
     list __tmp[64];
     list * __fill = &__tmp[0];
     list * __counter;

     do
       {
  __carry.splice(__carry.begin(), *this, begin());

  for(__counter = &__tmp[0];
      __counter != __fill && !__counter->empty();
      ++__counter)
    {
      __counter->merge(__carry, __comp);
      __carry.swap(*__counter);
    }
  __carry.swap(*__counter);
  if (__counter == __fill)
    ++__fill;
       }
     while ( !empty() );

     for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
       __counter->merge(*(__counter - 1), __comp);
     swap(*(__fill - 1));
   }
      }

}
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/list" 2 3
# 52 "/usr/include/qt4/QtCore/qlist.h" 2









typedef QtValidLicenseForCoreModule QtCoreModule;

template <typename T> class QVector;
template <typename T> class QSet;

struct QListData {
    struct Data {
        QBasicAtomicInt ref;
        int alloc, begin, end;
        uint sharable : 1;
        void *array[1];
    };
    enum { DataHeaderSize = sizeof(Data) - sizeof(void *) };

    Data *detach();
    Data *detach2();
    Data *detach3();
    void realloc(int alloc);
    static Data shared_null;
    Data *d;
    void **erase(void **xi);
    void **append();
    void **append(const QListData &l);
    void **append2(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 void detachShared()
    {

        if (d->ref != 1 && this->d != &QListData::shared_null)
            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 append(const QList<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);
    bool removeOne(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 == 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 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 int(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 int length() const { return p.size(); }
    inline T& first() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",263) : qt_noop()); return *begin(); }
    inline const T& first() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",264) : qt_noop()); return *begin(); }
    T& last() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",265) : qt_noop()); return *(--end()); }
    const T& last() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",266) : qt_noop()); return *(--end()); }
    inline void removeFirst() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",267) : qt_noop()); erase(begin()); }
    inline void removeLast() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",268) : qt_noop()); erase(--end()); }
    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
    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;
    typedef ptrdiff_t difference_type;
# 309 "/usr/include/qt4/QtCore/qlist.h"
    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)
{
    Node *current = from;
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        try {
            while(current != to) {
                current->v = new T(*reinterpret_cast<T*>(src->v));
                ++current;
                ++src;
            }
        } catch (...) {
            while (current-- != from)
                delete reinterpret_cast<T*>(current->v);
            throw;
        }

    } else if (QTypeInfo<T>::isComplex) {
        try {
            while(current != to) {
                new (current) T(*reinterpret_cast<T*>(src));
                ++current;
                ++src;
            }
        } catch (...) {
            while (current-- != from)
                (reinterpret_cast<T*>(current))->~T();
            throw;
        }
    } else {
        if (src != from && to - from > 0)
            memcpy(from, src, (to - from) * sizeof(Node *));
    }
}

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) {
        l.d->ref.ref();
        if (!d->ref.deref())
            free(d);
        d = l.d;
        if (!d->sharable)
            detach_helper();
    }
    return *this;
}
template <typename T>
inline typename QList<T>::iterator QList<T>::insert(iterator before, const T &t)
{
    int iBefore = int(before.i - reinterpret_cast<Node *>(p.begin()));
    Node *n = reinterpret_cast<Node *>(p.insert(iBefore));
    try {
        node_construct(n, t);
    } catch (...) {
        p.remove(iBefore);
        throw;
    }
    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
{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::at", "index out of range","/usr/include/qt4/QtCore/qlist.h",439) : qt_noop());
 return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline const T &QList<T>::operator[](int i) const
{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::operator[]", "index out of range","/usr/include/qt4/QtCore/qlist.h",443) : qt_noop());
 return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline T &QList<T>::operator[](int i)
{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::operator[]", "index out of range","/usr/include/qt4/QtCore/qlist.h",447) : qt_noop());
  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)
{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::take", "index out of range","/usr/include/qt4/QtCore/qlist.h",455) : qt_noop());
 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 *n = reinterpret_cast<Node *>(p.append());
        try {
            node_construct(n, t);
        } catch (...) {
            --d->end;
            throw;
        }
    } else {
        const T cpy(t);
        Node *n = reinterpret_cast<Node *>(p.append());
        try {
            node_construct(n, cpy);
        } catch (...) {
            --d->end;
            throw;
        }
    }
}

template <typename T>
inline void QList<T>::prepend(const T &t)
{
    detach();
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        Node *n = reinterpret_cast<Node *>(p.prepend());
        try {
            node_construct(n, t);
        } catch (...) {
            ++d->begin;
            throw;
        }
    } else {
        const T cpy(t);
        Node *n = reinterpret_cast<Node *>(p.prepend());
        try {
            node_construct(n, cpy);
        } catch (...) {
            ++d->begin;
            throw;
        }
    }
}

template <typename T>
inline void QList<T>::insert(int i, const T &t)
{
    detach();
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        Node *n = reinterpret_cast<Node *>(p.insert(i));
        try {
            node_construct(n, t);
        } catch (...) {
            p.remove(i);
            throw;
        }
    } else {
        const T cpy(t);
        Node *n = reinterpret_cast<Node *>(p.insert(i));
        try {
            node_construct(n, cpy);
        } catch (...) {
            p.remove(i);
            throw;
        }
    }
}

template <typename T>
inline void QList<T>::replace(int i, const T &t)
{
    ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::replace", "index out of range","/usr/include/qt4/QtCore/qlist.h",540) : qt_noop());
    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)
{
    ((!(i >= 0 && i < p.size() && j >= 0 && j < p.size())) ? qt_assert_x("QList<T>::swap", "index out of range",
 "/usr/include/qt4/QtCore/qlist.h"
# 553 "/usr/include/qt4/QtCore/qlist.h"
    ,
 554
# 553 "/usr/include/qt4/QtCore/qlist.h"
    ) : qt_noop())
                                                       ;
    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)
{
    ((!(from >= 0 && from < p.size() && to >= 0 && to < p.size())) ? qt_assert_x("QList<T>::move", "index out of range",
 "/usr/include/qt4/QtCore/qlist.h"
# 564 "/usr/include/qt4/QtCore/qlist.h"
    ,
 565
# 564 "/usr/include/qt4/QtCore/qlist.h"
    ) : qt_noop())
                                                      ;
    detach();
    p.move(from, to);
}

template<typename T>
 QList<T> QList<T>::mid(int pos, int alength) const
{
    if (alength < 0)
        alength = size() - pos;
    if (pos == 0 && alength == size())
        return *this;
    QList<T> cpy;
    if (pos + alength > size())
        alength = size() - pos;
    for (int i = pos; i < pos + alength; ++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.detach3();
    try {
        node_copy(reinterpret_cast<Node *>(p.begin()), reinterpret_cast<Node *>(p.end()), n);
    } catch (...) {
        qFree(d);
        d = x;
        throw;
    }

    if (!x->ref.deref())
        free(x);
}

template <typename T>
 QList<T>::~QList()
{
    if (d && !d->ref.deref())
        free(d);
}

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)
{
    detachShared();
    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>
 bool QList<T>::removeOne(const T &_t)
{
    detachShared();
    int index = indexOf(_t);
    if (index != -1) {
        removeAt(index);
        return true;
    }
    return false;
}

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.append2(l.p));
    try{
        node_copy(n, reinterpret_cast<Node *>(p.end()), reinterpret_cast<Node *>(l.p.begin()));
    } catch (...) {

        d->end -= int(reinterpret_cast<Node *>(p.end()) - n);
        throw;
    }
    return *this;
}

template <typename T>
inline void QList<T>::append(const QList<T> &t)
{
    *this += t;
}

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 int(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; typedef typename QList<T>::const_iterator const_iterator; QList<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(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() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qlist.h",778) : qt_noop()); return *n; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qlist.h",778) : qt_noop()); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } };




# 51 "/usr/include/qt4/QtCore/qobject.h" 2









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;
# 87 "/usr/include/qt4/QtCore/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 inEventHandler : 1;
    uint inThreadChangeEvent : 1;
    uint hasGuards : 1;
    uint unused : 22;
    int postedEvents;
    QMetaObject *metaObject;
};


class QObject
{
    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } 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); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private:
   
    inline QObjectPrivate* d_func() { return reinterpret_cast<QObjectPrivate *>(qGetPtrHelper(d_ptr)); } inline const QObjectPrivate* d_func() const { return reinterpret_cast<const QObjectPrivate *>(qGetPtrHelper(d_ptr)); } friend class QObjectPrivate;

public:
    explicit QObject(QObject *parent=0);
    virtual ~QObject();

    virtual bool event(QEvent *);
    virtual bool eventFilter(QObject *, QEvent *);
# 153 "/usr/include/qt4/QtCore/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 &aName = QString()) const
    { return qFindChild<T>(this, aName); }

    template<typename T>
    inline QList<T> findChildren(const QString &aName = QString()) const
    { return qFindChildren<T>(this, aName); }


    template<typename T>
    inline QList<T> findChildren(const QRegExp &re) const
    { return qFindChildren<T>(this, re); }
# 191 "/usr/include/qt4/QtCore/qobject.h"
    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::AutoConnection


        );
    inline bool connect(const QObject *sender, const char *signal,
                        const char *member, Qt::ConnectionType type =






                        Qt::AutoConnection


        ) 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;
    QList<QByteArray> dynamicPropertyNames() const;



    static uint registerUserData();
    void setUserData(uint id, QObjectUserData* data);
    QObjectUserData* userData(uint id) const;


public:
    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();

public:
    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);
# 292 "/usr/include/qt4/QtCore/qobject.h"
public:
    QObject(QObjectPrivate &dd, QObject *parent = 0);

public:
    QScopedPointer<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);
# 417 "/usr/include/qt4/QtCore/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;
    union {
        QList<T> *typedList;
        QList<void *> *voidList;
    } u;
    u.typedList = &list;
    qt_qFindChildren_helper(o, name, 0, reinterpret_cast<T>(0)->staticMetaObject, u.voidList);
    return list;
}


template<typename T>
inline QList<T> qFindChildren(const QObject *o, const QRegExp &re)
{
    QList<T> list;
    union {
        QList<T> *typedList;
        QList<void *> *voidList;
    } u;
    u.typedList = &list;
    qt_qFindChildren_helper(o, QString(), &re, reinterpret_cast<T>(0)->staticMetaObject, u.voidList);
    return list;
}


template <class T>
inline T qobject_cast(QObject *object)
{

    reinterpret_cast<T>(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(object));

    return static_cast<T>(reinterpret_cast<T>(0)->staticMetaObject.cast(object));
}

template <class T>
inline T qobject_cast(const QObject *object)
{

    register T ptr = static_cast<T>(object);
    (void)ptr;;


    reinterpret_cast<T>(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(const_cast<QObject *>(object)));

    return static_cast<T>(const_cast<QObject *>(reinterpret_cast<T>(0)->staticMetaObject.cast(const_cast<QObject *>(object))));
}


template <class T> inline const char * qobject_interface_iid()
{ return 0; }
# 488 "/usr/include/qt4/QtCore/qobject.h"
 QDebug operator<<(QDebug, const QObject *);





# 47 "/usr/include/qt4/QtCore/qiodevice.h" 2
# 57 "/usr/include/qt4/QtCore/qiodevice.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

class QByteArray;
class QIODevicePrivate;

class QIODevice

    : public QObject

{

    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } 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); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } 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);
    qint64 write(const char *data);
    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);
    bool putChar(char c);
    bool getChar(char *c);

    QString errorString() const;


public:
    void readyRead();
    void bytesWritten(qint64 bytes);
    void aboutToClose();
    void readChannelFinished();


public:



    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 *>(qGetPtrHelper(d_ptr)); } inline const QIODevicePrivate* d_func() const { return reinterpret_cast<const QIODevicePrivate *>(qGetPtrHelper(d_ptr)); } friend class QIODevicePrivate;
    QIODevice(const QIODevice &); QIODevice &operator=(const QIODevice &);
# 204 "/usr/include/qt4/QtCore/qiodevice.h"
};

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; } inline QIncompatibleFlag operator|(QIODevice::OpenMode::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
# 246 "/usr/include/qt4/QtCore/qiodevice.h"
class QDebug;
 QDebug operator<<(QDebug debug, QIODevice::OpenMode modes);





# 47 "/usr/include/qt4/QtCore/qdatastream.h" 2










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,
        Qt_4_2 = 8,
        Qt_4_3 = 9,
        Qt_4_4 = 10,
        Qt_4_5 = 11,
        Qt_4_6 = 12




    };

    enum ByteOrder {
        BigEndian = QSysInfo::BigEndian,
        LittleEndian = QSysInfo::LittleEndian
    };

    enum Status {
        Ok,
        ReadPastEnd,
 ReadCorruptData
    };

    enum FloatingPointPrecision {
        SinglePrecision,
        DoublePrecision
    };

    QDataStream();
    explicit QDataStream(QIODevice *);



    QDataStream(QByteArray *, QIODevice::OpenMode flags);
    QDataStream(const QByteArray &);
    virtual ~QDataStream();

    QIODevice *device() const;
    void setDevice(QIODevice *);
    void unsetDevice();

    bool atEnd() const;




    Status status() const;
    void setStatus(Status status);
    void resetStatus();

    FloatingPointPrecision floatingPointPrecision() const;
    void setFloatingPointPrecision(FloatingPointPrecision precision);

    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);
# 185 "/usr/include/qt4/QtCore/qdatastream.h"
private:
    QDataStream(const QDataStream &); QDataStream &operator=(const QDataStream &);

    QScopedPointer<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());
    for (typename QVector<T>::const_iterator it = v.begin(); 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.setInsertInOrder(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.setInsertInOrder(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;
}






# 47 "/usr/include/qt4/QtCore/qstringlist.h" 2

# 1 "/usr/include/qt4/QtCore/qregexp.h" 1
# 52 "/usr/include/qt4/QtCore/qregexp.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

struct QRegExpPrivate;
class QStringList;

class QRegExp
{
public:
    enum PatternSyntax {
        RegExp,
        Wildcard,
        FixedString,
        RegExp2,
        WildcardUnix,
        W3CXmlSchema11 };
    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);





    PatternSyntax patternSyntax() const;
    void setPatternSyntax(PatternSyntax syntax);






    bool isMinimal() const;
    void setMinimal(bool minimal);




    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;
# 120 "/usr/include/qt4/QtCore/qregexp.h"
    int matchedLength() const;


    int numCaptures() const;

    int captureCount() const;
    QStringList capturedTexts() const;
    QStringList capturedTexts();
    QString cap(int nth = 0) const;
    QString cap(int nth = 0);
    int pos(int nth = 0) const;
    int pos(int nth = 0);
    QString errorString() const;
    QString errorString();


    static QString escape(const QString &str);
# 147 "/usr/include/qt4/QtCore/qregexp.h"
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);





# 49 "/usr/include/qt4/QtCore/qstringlist.h" 2

# 1 "/usr/include/qt4/QtCore/qstringmatcher.h" 1
# 47 "/usr/include/qt4/QtCore/qstringmatcher.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

class QStringMatcherPrivate;

class QStringMatcher
{
public:
    QStringMatcher();
    QStringMatcher(const QString &pattern,
                   Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QStringMatcher(const QChar *uc, int len,
                   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;
    int indexIn(const QChar *str, int length, int from = 0) const;
    QString pattern() const;
    inline Qt::CaseSensitivity caseSensitivity() const { return q_cs; }

private:
    QStringMatcherPrivate *d_ptr;
    QString q_pattern;
    Qt::CaseSensitivity q_cs;





    struct Data {
        uchar q_skiptable[256];
        const QChar *uc;
        int len;
    };
    union {
        uint q_data[256];
        Data p;
    };



};




# 51 "/usr/include/qt4/QtCore/qstringlist.h" 2








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 int removeDuplicates();

    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(QRegExp &rx, int from = 0) const;
    inline int lastIndexOf(QRegExp &rx, int from = -1) const;


    using QList<QString>::indexOf;
    using QList<QString>::lastIndexOf;
# 126 "/usr/include/qt4/QtCore/qstringlist.h"
};

namespace QtPrivate {
    void QStringList_sort(QStringList *that);
    int QStringList_removeDuplicates(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);
    int QStringList_indexOf(const QStringList *that, QRegExp &rx, int from);
    int QStringList_lastIndexOf(const QStringList *that, QRegExp &rx, int from);

}

inline void QStringList::sort()
{
    QtPrivate::QStringList_sort(this);
}

inline int QStringList::removeDuplicates()
{
    return QtPrivate::QStringList_removeDuplicates(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 int QStringList::indexOf(QRegExp &rx, int from) const
{
    return QtPrivate::QStringList_indexOf(this, rx, from);
}

inline int QStringList::lastIndexOf(QRegExp &rx, int from) const
{
    return QtPrivate::QStringList_lastIndexOf(this, rx, from);
}
# 245 "/usr/include/qt4/QtCore/qstringlist.h"
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));
}





# 48 "/usr/include/qt4/QtGui/qcolor.h" 2





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, Hsl };

    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);
    QColor(Spec spec);

    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 hsvHue() const;
    int hsvSaturation() const;
    int value() const;

    qreal hueF() const;
    qreal saturationF() const;
    qreal hsvHueF() const;
    qreal hsvSaturationF() 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);

    int hslHue() const;
    int hslSaturation() const;
    int lightness() const;

    qreal hslHueF() const;
    qreal hslSaturationF() const;
    qreal lightnessF() const;

    void getHsl(int *h, int *s, int *l, int *a = 0) const;
    void setHsl(int h, int s, int l, int a = 255);

    void getHslF(qreal *h, qreal *s, qreal *l, qreal *a = 0) const;
    void setHslF(qreal h, qreal s, qreal l, qreal a = 1.0);

    QColor toRgb() const;
    QColor toHsv() const;
    QColor toCmyk() const;
    QColor toHsl() 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);

    static QColor fromHsl(int h, int s, int l, int a = 255);
    static QColor fromHslF(qreal h, qreal s, qreal l, qreal a = 1.0);

    QColor light(int f = 150) const;
    QColor lighter(int f = 150) const;
    QColor dark(int f = 200) const;
    QColor darker(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;


    static bool allowX11ColorNames();
    static void setAllowX11ColorNames(bool enabled);
# 228 "/usr/include/qt4/QtGui/qcolor.h"
private:


    QColor(int, int, int, Spec);


    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;
        struct {
            ushort alpha;
            ushort hue;
            ushort saturation;
            ushort lightness;
            ushort pad;
        } ahsl;
        ushort array[5];
    } 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; }

inline QColor QColor::lighter(int f) const
{ return light(f); }

inline QColor QColor::darker(int f) const
{ return dark(f); }




# 47 "/usr/include/qt4/QtGui/qpixmap.h" 2


# 1 "/usr/include/qt4/QtCore/qsharedpointer.h" 1
# 47 "/usr/include/qt4/QtCore/qsharedpointer.h"
# 1 "/usr/include/qt4/QtCore/qshareddata.h" 1
# 48 "/usr/include/qt4/QtCore/qshareddata.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

template <class T> class QSharedDataPointer;

class QSharedData
{
public:
    mutable QAtomicInt ref;

    inline QSharedData() : ref(0) { }
    inline QSharedData(const QSharedData &) : ref(0) { }

private:

    QSharedData &operator=(const QSharedData &);
};

template <class T> class QSharedDataPointer
{
public:
    typedef T Type;
    typedef T *pointer;

    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) {
            if (o.d)
                o.d->ref.ref();
            if (d && !d->ref.deref())
                delete d;
            d = o.d;
        }
        return *this;
    }
    inline QSharedDataPointer &operator=(T *o) {
        if (o != d) {
            if (o)
                o->ref.ref();
            if (d && !d->ref.deref())
                delete d;
            d = o;
        }
        return *this;
    }

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

    inline void swap(QSharedDataPointer &other)
    { qSwap(d, other.d); }

public:
    T *clone();

private:
    void detach_helper();

    T *d;
};

template <class T> class QExplicitlySharedDataPointer
{
public:
    typedef T Type;
    typedef T *pointer;

    inline T &operator*() const { return *d; }
    inline T *operator->() { return d; }
    inline T *operator->() const { return d; }
    inline T *data() const { return d; }
    inline const T *constData() const { return d; }

    inline void detach() { if (d && d->ref != 1) detach_helper(); }

    inline void reset()
    {
        if(d && !d->ref.deref())
            delete d;

        d = 0;
    }

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

    inline bool operator==(const QExplicitlySharedDataPointer<T> &other) const { return d == other.d; }
    inline bool operator!=(const QExplicitlySharedDataPointer<T> &other) const { return d != other.d; }
    inline bool operator==(const T *ptr) const { return d == ptr; }
    inline bool operator!=(const T *ptr) const { return d != ptr; }

    inline QExplicitlySharedDataPointer() { d = 0; }
    inline ~QExplicitlySharedDataPointer() { if (d && !d->ref.deref()) delete d; }

    explicit QExplicitlySharedDataPointer(T *data);
    inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }


    template<class X>
    inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o) : d(static_cast<T *>(o.data()))
    {
        if(d)
            d->ref.ref();
    }


    inline QExplicitlySharedDataPointer<T> & operator=(const QExplicitlySharedDataPointer<T> &o) {
        if (o.d != d) {
            if (o.d)
                o.d->ref.ref();
            if (d && !d->ref.deref())
                delete d;
            d = o.d;
        }
        return *this;
    }
    inline QExplicitlySharedDataPointer &operator=(T *o) {
        if (o != d) {
            if (o)
                o->ref.ref();
            if (d && !d->ref.deref())
                delete d;
            d = o;
        }
        return *this;
    }

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

    inline void swap(QExplicitlySharedDataPointer &other)
    { qSwap(d, other.d); }

public:
    T *clone();

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>
inline T *QSharedDataPointer<T>::clone()
{
    return new T(*d);
}

template <class T>
 void QSharedDataPointer<T>::detach_helper()
{
    T *x = clone();
    x->ref.ref();
    if (!d->ref.deref())
        delete d;
    d = x;
}

template <class T>
inline T *QExplicitlySharedDataPointer<T>::clone()
{
    return new T(*d);
}

template <class T>
 void QExplicitlySharedDataPointer<T>::detach_helper()
{
    T *x = clone();
    x->ref.ref();
    if (!d->ref.deref())
        delete d;
    d = x;
}

template <class T>
inline QExplicitlySharedDataPointer<T>::QExplicitlySharedDataPointer(T *adata) : d(adata)
{ if (d) d->ref.ref(); }

template <class T>
inline void qSwap(QSharedDataPointer<T> &p1, QSharedDataPointer<T> &p2)
{ p1.swap(p2); }

template <class T>
inline void qSwap(QExplicitlySharedDataPointer<T> &p1, QExplicitlySharedDataPointer<T> &p2)
{ p1.swap(p2); }




# 48 "/usr/include/qt4/QtCore/qsharedpointer.h" 2




# 1 "/usr/include/qt4/QtCore/qsharedpointer_impl.h" 1
# 55 "/usr/include/qt4/QtCore/qsharedpointer_impl.h"




typedef QtValidLicenseForCoreModule QtCoreModule;
# 70 "/usr/include/qt4/QtCore/qsharedpointer_impl.h"
template<typename T> inline void qt_sharedpointer_cast_check(T *) { }







template <class T> class QWeakPointer;
template <class T> class QSharedPointer;

template <class X, class T>
QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &ptr);
template <class X, class T>
QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &ptr);
template <class X, class T>
QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &ptr);


template <class X, class T>
QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &ptr);


namespace QtSharedPointer {
    template <class T> class InternalRefCount;
    template <class T> class ExternalRefCount;

    template <class X, class Y> QSharedPointer<X> copyAndSetPointer(X * ptr, const QSharedPointer<Y> &src);


    void internalSafetyCheckAdd2(const void *, const volatile void *);
    void internalSafetyCheckRemove2(const void *);

    template <class T, typename Klass, typename RetVal>
    inline void executeDeleter(T *t, RetVal (Klass:: *memberDeleter)())
    { (t->*memberDeleter)(); }
    template <class T, typename Deleter>
    inline void executeDeleter(T *t, Deleter d)
    { d(t); }
    template <class T> inline void normalDeleter(T *t) { delete t; }



    template <class T> struct RemovePointer;
    template <class T> struct RemovePointer<T *> { typedef T Type; };
    template <class T> struct RemovePointer<QSharedPointer<T> > { typedef T Type; };
    template <class T> struct RemovePointer<QWeakPointer<T> > { typedef T Type; };




    template <class T>
    class Basic
    {

        typedef T *Basic:: *RestrictedBool;

    public:
        typedef T Type;
        typedef T element_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;
        typedef ptrdiff_t difference_type;

        inline T *data() const { return value; }
        inline bool isNull() const { return !data(); }

        inline operator RestrictedBool() const { return isNull() ? 0 : &Basic::value; }



        inline bool operator !() const { return isNull(); }
        inline T &operator*() const { return *data(); }
        inline T *operator->() const { return data(); }

    public:
        inline Basic(T *ptr = 0) : value(ptr) { }
        inline Basic(Qt::Initialization) { }


        inline void internalConstruct(T *ptr)
        {
            value = ptr;
        }




        template <class X> friend class QWeakPointer;


        Type *value;
    };







    struct ExternalRefCountData
    {
        QBasicAtomicInt weakref;
        QBasicAtomicInt strongref;

        inline ExternalRefCountData()
        {
            strongref = 1;
            weakref = 1;
        }
        inline ExternalRefCountData(Qt::Initialization) { }
        virtual inline ~ExternalRefCountData() { ((!(!weakref)) ? qt_assert("!weakref","/usr/include/qt4/QtCore/qsharedpointer_impl.h",184) : qt_noop()); ((!(strongref <= 0)) ? qt_assert("strongref <= 0","/usr/include/qt4/QtCore/qsharedpointer_impl.h",184) : qt_noop()); }




        virtual inline bool destroy() { return false; }


        static ExternalRefCountData *getAndRef(const QObject *);
        void setQObjectShared(const QObject *, bool enable);

        inline void setQObjectShared(...) { }
    };




    struct ExternalRefCountWithDestroyFn: public ExternalRefCountData
    {
        typedef void (*DestroyerFn)(ExternalRefCountData *);
        DestroyerFn destroyer;

        inline ExternalRefCountWithDestroyFn(DestroyerFn d)
            : destroyer(d)
        { }

        inline bool destroy() { destroyer(this); return true; }
        inline void operator delete(void *ptr) { ::operator delete(ptr); }
    };





    template <class T, typename Deleter>
    struct ExternalRefCountWithCustomDeleter: public ExternalRefCountWithDestroyFn
    {
        typedef ExternalRefCountWithCustomDeleter Self;
        typedef ExternalRefCountWithDestroyFn BaseClass;

        struct CustomDeleter
        {
            Deleter deleter;
            T *ptr;

            inline CustomDeleter(T *p, Deleter d) : deleter(d), ptr(p) {}
        };
        CustomDeleter extra;




        static inline void deleter(ExternalRefCountData *self)
        {
            Self *realself = static_cast<Self *>(self);
            executeDeleter(realself->extra.ptr, realself->extra.deleter);


            realself->extra.~CustomDeleter();
        }
        static void safetyCheckDeleter(ExternalRefCountData *self)
        {
            internalSafetyCheckRemove2(self);
            deleter(self);
        }

        static inline Self *create(T *ptr, Deleter userDeleter)
        {



            DestroyerFn destroy = &deleter;

            Self *d = static_cast<Self *>(::operator new(sizeof(Self)));


            new (&d->extra) CustomDeleter(ptr, userDeleter);
            new (d) BaseClass(destroy);

            return d;
        }
    private:

        ExternalRefCountWithCustomDeleter();
        ~ExternalRefCountWithCustomDeleter();
    };





    template <class T>
    struct ExternalRefCountWithContiguousData: public ExternalRefCountWithDestroyFn
    {
        typedef ExternalRefCountWithDestroyFn Parent;
        T data;

        static void deleter(ExternalRefCountData *self)
        {
            ExternalRefCountWithContiguousData *that =
                    static_cast<ExternalRefCountWithContiguousData *>(self);
            that->data.~T();
        }
        static void safetyCheckDeleter(ExternalRefCountData *self)
        {
            internalSafetyCheckRemove2(self);
            deleter(self);
        }

        static inline ExternalRefCountData *create(T **ptr)
        {



            DestroyerFn destroy = &deleter;

            ExternalRefCountWithContiguousData *d =
                static_cast<ExternalRefCountWithContiguousData *>(::operator new(sizeof(ExternalRefCountWithContiguousData)));



            new (d) Parent(destroy);

            *ptr = &d->data;
            return d;
        }

    private:

        ExternalRefCountWithContiguousData();
        ~ExternalRefCountWithContiguousData();
    };



    template <class T>
    class ExternalRefCount: public Basic<T>
    {
    public:
        typedef ExternalRefCountData Data;

        inline void ref() const { d->weakref.ref(); d->strongref.ref(); }
        inline bool deref()
        {
            if (!d->strongref.deref()) {
                internalDestroy();
            }
            return d->weakref.deref();
        }

        inline void internalConstruct(T *ptr)
        {



            if (ptr)
                d = new Data;
            else
                d = 0;
            internalFinishConstruction(ptr);

        }

        template <typename Deleter>
        inline void internalConstruct(T *ptr, Deleter deleter)
        {
            if (ptr)
                d = ExternalRefCountWithCustomDeleter<T, Deleter>::create(ptr, deleter);
            else
                d = 0;
            internalFinishConstruction(ptr);
        }

        inline void internalCreate()
        {
            T *ptr;
            d = ExternalRefCountWithContiguousData<T>::create(&ptr);
            Basic<T>::internalConstruct(ptr);
        }

        inline void internalFinishConstruction(T *ptr)
        {
            Basic<T>::internalConstruct(ptr);
            if (ptr) d->setQObjectShared(ptr, true);



        }

        inline ExternalRefCount() : d(0) { }
        inline ExternalRefCount(Qt::Initialization i) : Basic<T>(i) { }
        inline ExternalRefCount(const ExternalRefCount<T> &other) : Basic<T>(other), d(other.d)
        { if (d) ref(); }
        template <class X>
        inline ExternalRefCount(const ExternalRefCount<X> &other) : Basic<T>(other.value), d(other.d)
        { if (d) ref(); }
        inline ~ExternalRefCount() { if (d && !deref()) delete d; }

        template <class X>
        inline void internalCopy(const ExternalRefCount<X> &other)
        {
            internalSet(other.d, other.data());
        }

        inline void internalDestroy()
        {
            if (!d->destroy())
                delete this->value;
        }

        inline void internalSwap(ExternalRefCount &other)
        {
            qSwap(d, other.d);
            qSwap(this->value, other.value);
        }




        template <class X> friend class ExternalRefCount;
        template <class X> friend class QWeakPointer;
        template <class X, class Y> friend QSharedPointer<X> copyAndSetPointer(X * ptr, const QSharedPointer<Y> &src);


        inline void internalSet(Data *o, T *actual)
        {
            if (o) {


                register int tmp = o->strongref;
                while (tmp > 0) {

                    if (o->strongref.testAndSetRelaxed(tmp, tmp + 1))
                        break;
                    tmp = o->strongref;
                }

                if (tmp > 0)
                    o->weakref.ref();
                else
                    o = 0;
            }
            if (d && !deref())
                delete d;
            d = o;
            this->value = d && d->strongref ? actual : 0;
        }

        Data *d;

    private:
        template<class X> ExternalRefCount(const InternalRefCount<X> &);
    };
}

template <class T>
class QSharedPointer: public QtSharedPointer::ExternalRefCount<T>
{
    typedef typename QtSharedPointer::ExternalRefCount<T> BaseClass;
public:
    inline QSharedPointer() { }


    inline explicit QSharedPointer(T *ptr) : BaseClass(Qt::Uninitialized)
    { BaseClass::internalConstruct(ptr); }

    template <typename Deleter>
    inline QSharedPointer(T *ptr, Deleter d) { BaseClass::internalConstruct(ptr, d); }

    inline QSharedPointer(const QSharedPointer<T> &other) : BaseClass(other) { }
    inline QSharedPointer<T> &operator=(const QSharedPointer<T> &other)
    {
        BaseClass::internalCopy(other);
        return *this;
    }

    template <class X>
    inline QSharedPointer(const QSharedPointer<X> &other) : BaseClass(other)
    { }

    template <class X>
    inline QSharedPointer<T> &operator=(const QSharedPointer<X> &other)
    {
        qt_sharedpointer_cast_check<T>(static_cast<X *>(0));
        BaseClass::internalCopy(other);
        return *this;
    }

    template <class X>
    inline QSharedPointer(const QWeakPointer<X> &other) : BaseClass(Qt::Uninitialized)
    { this->d = 0; *this = other; }

    template <class X>
    inline QSharedPointer<T> &operator=(const QWeakPointer<X> &other)
    { BaseClass::internalSet(other.d, other.value); return *this; }

    inline void swap(QSharedPointer &other)
    { QSharedPointer<T>::internalSwap(other); }

    template <class X>
    QSharedPointer<X> staticCast() const
    {
        return qSharedPointerCast<X, T>(*this);
    }

    template <class X>
    QSharedPointer<X> dynamicCast() const
    {
        return qSharedPointerDynamicCast<X, T>(*this);
    }

    template <class X>
    QSharedPointer<X> constCast() const
    {
        return qSharedPointerConstCast<X, T>(*this);
    }


    template <class X>
    QSharedPointer<X> objectCast() const
    {
        return qSharedPointerObjectCast<X, T>(*this);
    }


    inline void clear() { *this = QSharedPointer<T>(); }

    QWeakPointer<T> toWeakRef() const;

public:
    inline explicit QSharedPointer(Qt::Initialization i) : BaseClass(i) {}

public:
    static inline QSharedPointer<T> create()
    {
        QSharedPointer<T> result(Qt::Uninitialized);
        result.internalCreate();


        new (result.data()) T();
        result.internalFinishConstruction(result.data());
        return result;
    }
};

template <class T>
class QWeakPointer
{

    typedef T *QWeakPointer:: *RestrictedBool;

    typedef QtSharedPointer::ExternalRefCountData Data;

public:
    typedef T element_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;
    typedef ptrdiff_t difference_type;

    inline bool isNull() const { return d == 0 || d->strongref == 0 || value == 0; }

    inline operator RestrictedBool() const { return isNull() ? 0 : &QWeakPointer::value; }



    inline bool operator !() const { return isNull(); }
    inline T *data() const { return d == 0 || d->strongref == 0 ? 0 : value; }

    inline QWeakPointer() : d(0), value(0) { }
    inline ~QWeakPointer() { if (d && !d->weakref.deref()) delete d; }



    template <class X>
    inline QWeakPointer(X *ptr) : d(ptr ? d->getAndRef(ptr) : 0), value(ptr)
    { }

    template <class X>
    inline QWeakPointer &operator=(X *ptr)
    { return *this = QWeakPointer(ptr); }

    inline QWeakPointer(const QWeakPointer<T> &o) : d(o.d), value(o.value)
    { if (d) d->weakref.ref(); }
    inline QWeakPointer<T> &operator=(const QWeakPointer<T> &o)
    {
        internalSet(o.d, o.value);
        return *this;
    }

    inline QWeakPointer(const QSharedPointer<T> &o) : d(o.d), value(o.data())
    { if (d) d->weakref.ref();}
    inline QWeakPointer<T> &operator=(const QSharedPointer<T> &o)
    {
        internalSet(o.d, o.value);
        return *this;
    }

    template <class X>
    inline QWeakPointer(const QWeakPointer<X> &o) : d(0), value(0)
    { *this = o; }

    template <class X>
    inline QWeakPointer<T> &operator=(const QWeakPointer<X> &o)
    {


        *this = o.toStrongRef();
        return *this;
    }

    template <class X>
    inline bool operator==(const QWeakPointer<X> &o) const
    { return d == o.d && value == static_cast<const T *>(o.value); }

    template <class X>
    inline bool operator!=(const QWeakPointer<X> &o) const
    { return !(*this == o); }

    template <class X>
    inline QWeakPointer(const QSharedPointer<X> &o) : d(0), value(0)
    { *this = o; }

    template <class X>
    inline QWeakPointer<T> &operator=(const QSharedPointer<X> &o)
    {
        qt_sharedpointer_cast_check<T>(static_cast<X *>(0));
        internalSet(o.d, o.data());
        return *this;
    }

    template <class X>
    inline bool operator==(const QSharedPointer<X> &o) const
    { return d == o.d; }

    template <class X>
    inline bool operator!=(const QSharedPointer<X> &o) const
    { return !(*this == o); }

    inline void clear() { *this = QWeakPointer<T>(); }

    inline QSharedPointer<T> toStrongRef() const { return QSharedPointer<T>(*this); }





private:




    template <class X> friend class QSharedPointer;


    inline void internalSet(Data *o, T *actual)
    {
        if (d == o) return;
        if (o)
            o->weakref.ref();
        if (d && !d->weakref.deref())
            delete d;
        d = o;
        value = actual;
    }

    Data *d;
    T *value;
};

template <class T, class X>
bool operator==(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
{
    return ptr1.data() == ptr2.data();
}
template <class T, class X>
bool operator!=(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
{
    return ptr1.data() != ptr2.data();
}

template <class T, class X>
bool operator==(const QSharedPointer<T> &ptr1, const X *ptr2)
{
    return ptr1.data() == ptr2;
}
template <class T, class X>
bool operator==(const T *ptr1, const QSharedPointer<X> &ptr2)
{
    return ptr1 == ptr2.data();
}

template <class T, class X>
bool operator!=(const QSharedPointer<T> &ptr1, const X *ptr2)
{
    return !(ptr1 == ptr2);
}
template <class T, class X>
bool operator!=(const T *ptr1, const QSharedPointer<X> &ptr2)
{
    return !(ptr2 == ptr1);
}

template <class T, class X>
bool operator==(const QSharedPointer<T> &ptr1, const QWeakPointer<X> &ptr2)
{
    return ptr2 == ptr1;
}
template <class T, class X>
bool operator!=(const QSharedPointer<T> &ptr1, const QWeakPointer<X> &ptr2)
{
    return ptr2 != ptr1;
}

template <class T, class X>
inline typename T::difference_type operator-(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
{
    return ptr1.data() - ptr2.data();
}

template <class T>
inline QWeakPointer<T> QSharedPointer<T>::toWeakRef() const
{
    return QWeakPointer<T>(*this);
}

template <class T>
inline void qSwap(QSharedPointer<T> &p1, QSharedPointer<T> &p2)
{
    p1.swap(p2);
}

namespace QtSharedPointer {

    template <class X, class T>
    inline QSharedPointer<X> copyAndSetPointer(X *ptr, const QSharedPointer<T> &src)
    {
        QSharedPointer<X> result;
        result.internalSet(src.d, ptr);
        return result;
    }
}


template <class X, class T>
inline QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &src)
{
    register X *ptr = static_cast<X *>(src.data());
    return QtSharedPointer::copyAndSetPointer(ptr, src);
}
template <class X, class T>
inline QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &src)
{
    return qSharedPointerCast<X, T>(src.toStrongRef());
}

template <class X, class T>
inline QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)
{
    register X *ptr = dynamic_cast<X *>(src.data());
    return QtSharedPointer::copyAndSetPointer(ptr, src);
}
template <class X, class T>
inline QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)
{
    return qSharedPointerDynamicCast<X, T>(src.toStrongRef());
}

template <class X, class T>
inline QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)
{
    register X *ptr = const_cast<X *>(src.data());
    return QtSharedPointer::copyAndSetPointer(ptr, src);
}
template <class X, class T>
inline QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)
{
    return qSharedPointerConstCast<X, T>(src.toStrongRef());
}

template <class X, class T>
inline
QWeakPointer<X> qWeakPointerCast(const QSharedPointer<T> &src)
{
    return qSharedPointerCast<X, T>(src).toWeakRef();
}


template <class X, class T>
inline QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)
{
    register X *ptr = qobject_cast<X *>(src.data());
    return QtSharedPointer::copyAndSetPointer(ptr, src);
}
template <class X, class T>
inline QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)
{
    return qSharedPointerObjectCast<X>(src.toStrongRef());
}

template <class X, class T>
inline QSharedPointer<typename QtSharedPointer::RemovePointer<X>::Type>
qobject_cast(const QSharedPointer<T> &src)
{
    return qSharedPointerObjectCast<typename QtSharedPointer::RemovePointer<X>::Type, T>(src);
}
template <class X, class T>
inline QSharedPointer<typename QtSharedPointer::RemovePointer<X>::Type>
qobject_cast(const QWeakPointer<T> &src)
{
    return qSharedPointerObjectCast<typename QtSharedPointer::RemovePointer<X>::Type, T>(src);
}






# 53 "/usr/include/qt4/QtCore/qsharedpointer.h" 2
# 50 "/usr/include/qt4/QtGui/qpixmap.h" 2
# 1 "/usr/include/qt4/QtGui/qimage.h" 1
# 45 "/usr/include/qt4/QtGui/qimage.h"
# 1 "/usr/include/qt4/QtGui/qtransform.h" 1
# 44 "/usr/include/qt4/QtGui/qtransform.h"
# 1 "/usr/include/qt4/QtGui/qmatrix.h" 1
# 45 "/usr/include/qt4/QtGui/qmatrix.h"
# 1 "/usr/include/qt4/QtGui/qpolygon.h" 1
# 45 "/usr/include/qt4/QtGui/qpolygon.h"
# 1 "/usr/include/qt4/QtCore/qvector.h" 1
# 52 "/usr/include/qt4/QtCore/qvector.h"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 1 3
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 3
       
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_construct.h" 1 3
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_construct.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {





  template<typename _T1, typename _T2>
    inline void




    _Construct(_T1* __p, const _T2& __value)

    {


      ::new(static_cast<void*>(__p)) _T1((__value));
    }




  template<typename _Tp>
    inline void
    _Destroy(_Tp* __pointer)
    { __pointer->~_Tp(); }

  template<bool>
    struct _Destroy_aux
    {
      template<typename _ForwardIterator>
        static void
        __destroy(_ForwardIterator __first, _ForwardIterator __last)
 {
   for (; __first != __last; ++__first)
     std::_Destroy(&*__first);
 }
    };

  template<>
    struct _Destroy_aux<true>
    {
      template<typename _ForwardIterator>
        static void
        __destroy(_ForwardIterator, _ForwardIterator) { }
    };






  template<typename _ForwardIterator>
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;
      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
 __destroy(__first, __last);
    }







  template <typename _Tp> class allocator;

  template<typename _ForwardIterator, typename _Allocator>
    void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      _Allocator& __alloc)
    {
      for (; __first != __last; ++__first)
 __alloc.destroy(&*__first);
    }

  template<typename _ForwardIterator, typename _Tp>
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      allocator<_Tp>&)
    {
      _Destroy(__first, __last);
    }

}
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 1 3
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  template<bool>
    struct __uninitialized_copy
    {
      template<typename _InputIterator, typename _ForwardIterator>
        static _ForwardIterator
        uninitialized_copy(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result)
        {
   _ForwardIterator __cur = __result;
   try
     {
       for (; __first != __last; ++__first, ++__cur)
  std::_Construct(&*__cur, *__first);
       return __cur;
     }
   catch(...)
     {
       std::_Destroy(__result, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_copy<true>
    {
      template<typename _InputIterator, typename _ForwardIterator>
        static _ForwardIterator
        uninitialized_copy(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result)
        { return std::copy(__first, __last, __result); }
    };
# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    uninitialized_copy(_InputIterator __first, _InputIterator __last,
         _ForwardIterator __result)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _ValueType1;
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType2;

      return std::__uninitialized_copy<(__is_pod(_ValueType1)
     && __is_pod(_ValueType2))>::
 uninitialized_copy(__first, __last, __result);
    }


  template<bool>
    struct __uninitialized_fill
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        uninitialized_fill(_ForwardIterator __first,
      _ForwardIterator __last, const _Tp& __x)
        {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __cur != __last; ++__cur)
  std::_Construct(&*__cur, __x);
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_fill<true>
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        uninitialized_fill(_ForwardIterator __first,
      _ForwardIterator __last, const _Tp& __x)
        { std::fill(__first, __last, __x); }
    };
# 161 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline void
    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
         const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      std::__uninitialized_fill<__is_pod(_ValueType)>::
 uninitialized_fill(__first, __last, __x);
    }


  template<bool>
    struct __uninitialized_construct_range_dispatch
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        __ucr(_ForwardIterator __first, _ForwardIterator __last,
       _Tp& __value)
        {
   if(__first == __last)
     return;

   _ForwardIterator __cur = __first;
   try
     {
       std::_Construct(&*__first, (__value));
       _ForwardIterator __prev = __cur;
       ++__cur;
       for(; __cur != __last; ++__cur, ++__prev)
  std::_Construct(&*__cur, (*__prev));
       __value = (*__prev);
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_construct_range_dispatch<true>
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        __ucr(_ForwardIterator, _ForwardIterator, _Tp&) { }
    };
# 221 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline void
    __uninitialized_construct_range(_ForwardIterator __first,
        _ForwardIterator __last,
        _Tp& __value)
    {
      typedef typename std::iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      std::__uninitialized_construct_range_dispatch<
        __has_trivial_constructor(_ValueType)>::
   __ucr(__first, __last, __value);
    }


  template<bool>
    struct __uninitialized_fill_n
    {
      template<typename _ForwardIterator, typename _Size, typename _Tp>
        static void
        uninitialized_fill_n(_ForwardIterator __first, _Size __n,
        const _Tp& __x)
        {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __n > 0; --__n, ++__cur)
  std::_Construct(&*__cur, __x);
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_fill_n<true>
    {
      template<typename _ForwardIterator, typename _Size, typename _Tp>
        static void
        uninitialized_fill_n(_ForwardIterator __first, _Size __n,
        const _Tp& __x)
        { std::fill_n(__first, __n, __x); }
    };
# 277 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Size, typename _Tp>
    inline void
    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      std::__uninitialized_fill_n<__is_pod(_ValueType)>::
 uninitialized_fill_n(__first, __n, __x);
    }







  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __result;
      try
 {
   for (; __first != __last; ++__first, ++__cur)
     __alloc.construct(&*__cur, *__first);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__result, __cur, __alloc);
   throw;
 }
    }

  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
    inline _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, allocator<_Tp>&)
    { return std::uninitialized_copy(__first, __last, __result); }

  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    inline _ForwardIterator
    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, _Allocator& __alloc)
    {
      return std::__uninitialized_copy_a((__first),
      (__last),
      __result, __alloc);
    }

  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
    void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   for (; __cur != __last; ++__cur)
     __alloc.construct(&*__cur, __x);
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }

  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
    inline void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, allocator<_Tp2>&)
    { std::uninitialized_fill(__first, __last, __x); }

  template<typename _ForwardIterator, typename _Size, typename _Tp,
    typename _Allocator>
    void
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   for (; __n > 0; --__n, ++__cur)
     __alloc.construct(&*__cur, __x);
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }

  template<typename _ForwardIterator, typename _Size, typename _Tp,
    typename _Tp2>
    inline void
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x, allocator<_Tp2>&)
    { std::uninitialized_fill_n(__first, __n, __x); }
# 391 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _ForwardIterator, typename _Allocator>
    inline _ForwardIterator
    __uninitialized_copy_move(_InputIterator1 __first1,
         _InputIterator1 __last1,
         _InputIterator2 __first2,
         _InputIterator2 __last2,
         _ForwardIterator __result,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
          __result,
          __alloc);
      try
 {
   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }





  template<typename _InputIterator1, typename _InputIterator2,
    typename _ForwardIterator, typename _Allocator>
    inline _ForwardIterator
    __uninitialized_move_copy(_InputIterator1 __first1,
         _InputIterator1 __last1,
         _InputIterator2 __first2,
         _InputIterator2 __last2,
         _ForwardIterator __result,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
          __result,
          __alloc);
      try
 {
   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }




  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
    typename _Allocator>
    inline _ForwardIterator
    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
         const _Tp& __x, _InputIterator __first,
         _InputIterator __last, _Allocator& __alloc)
    {
      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
      try
 {
   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }




  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
    typename _Allocator>
    inline void
    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
         _ForwardIterator __first2,
         _ForwardIterator __last2, const _Tp& __x,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
           __first2,
           __alloc);
      try
 {
   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__first2, __mid2, __alloc);
   throw;
 }
    }
# 537 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
}
# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 1 3
# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {


  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    {
      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;

      struct _Vector_impl
      : public _Tp_alloc_type
      {
 typename _Tp_alloc_type::pointer _M_start;
 typename _Tp_alloc_type::pointer _M_finish;
 typename _Tp_alloc_type::pointer _M_end_of_storage;

 _Vector_impl()
 : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
 { }

 _Vector_impl(_Tp_alloc_type const& __a)
 : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
 { }
      };

    public:
      typedef _Alloc allocator_type;

      _Tp_alloc_type&
      _M_get_Tp_allocator()
      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }

      const _Tp_alloc_type&
      _M_get_Tp_allocator() const
      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }

      allocator_type
      get_allocator() const
      { return allocator_type(_M_get_Tp_allocator()); }

      _Vector_base()
      : _M_impl() { }

      _Vector_base(const allocator_type& __a)
      : _M_impl(__a) { }

      _Vector_base(size_t __n, const allocator_type& __a)
      : _M_impl(__a)
      {
 this->_M_impl._M_start = this->_M_allocate(__n);
 this->_M_impl._M_finish = this->_M_impl._M_start;
 this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
      }
# 131 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      ~_Vector_base()
      { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
        - this->_M_impl._M_start); }

    public:
      _Vector_impl _M_impl;

      typename _Tp_alloc_type::pointer
      _M_allocate(size_t __n)
      { return __n != 0 ? _M_impl.allocate(__n) : 0; }

      void
      _M_deallocate(typename _Tp_alloc_type::pointer __p, size_t __n)
      {
 if (__p)
   _M_impl.deallocate(__p, __n);
      }
    };
# 169 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class vector : public _Vector_base<_Tp, _Alloc>
    {

      typedef typename _Alloc::value_type _Alloc_value_type;
     
     

      typedef _Vector_base<_Tp, _Alloc> _Base;
      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;

    public:
      typedef _Tp value_type;
      typedef typename _Tp_alloc_type::pointer pointer;
      typedef typename _Tp_alloc_type::const_pointer const_pointer;
      typedef typename _Tp_alloc_type::reference reference;
      typedef typename _Tp_alloc_type::const_reference const_reference;
      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
      const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

    public:
      using _Base::_M_allocate;
      using _Base::_M_deallocate;
      using _Base::_M_impl;
      using _Base::_M_get_Tp_allocator;

    public:





      vector()
      : _Base() { }





      explicit
      vector(const allocator_type& __a)
      : _Base(__a) { }
# 226 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      explicit
      vector(size_type __n, const value_type& __value = value_type(),
      const allocator_type& __a = allocator_type())
      : _Base(__n, __a)
      { _M_fill_initialize(__n, __value); }
# 241 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      vector(const vector& __x)
      : _Base(__x.size(), __x._M_get_Tp_allocator())
      { this->_M_impl._M_finish =
   std::__uninitialized_copy_a(__x.begin(), __x.end(),
          this->_M_impl._M_start,
          _M_get_Tp_allocator());
      }
# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      template<typename _InputIterator>
        vector(_InputIterator __first, _InputIterator __last,
        const allocator_type& __a = allocator_type())
 : _Base(__a)
        {

   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_initialize_dispatch(__first, __last, _Integral());
 }







      ~vector()
      { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
        _M_get_Tp_allocator()); }
# 324 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      vector&
      operator=(const vector& __x);
# 374 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      template<typename _InputIterator>
        void
        assign(_InputIterator __first, _InputIterator __last)
        {

   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_assign_dispatch(__first, __last, _Integral());
 }
# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      using _Base::get_allocator;







      iterator
      begin()
      { return iterator(this->_M_impl._M_start); }






      const_iterator
      begin() const
      { return const_iterator(this->_M_impl._M_start); }






      iterator
      end()
      { return iterator(this->_M_impl._M_finish); }






      const_iterator
      end() const
      { return const_iterator(this->_M_impl._M_finish); }






      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()); }
# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      size_type
      size() const
      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }


      size_type
      max_size() const
      { return _M_get_Tp_allocator().max_size(); }
# 552 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      void
      resize(size_type __new_size, value_type __x = value_type())
      {
 if (__new_size < size())
   _M_erase_at_end(this->_M_impl._M_start + __new_size);
 else
   insert(end(), __new_size - size(), __x);
      }
# 572 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      size_type
      capacity() const
      { return size_type(this->_M_impl._M_end_of_storage
    - this->_M_impl._M_start); }





      bool
      empty() const
      { return begin() == end(); }
# 602 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      void
      reserve(size_type __n);
# 617 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      reference
      operator[](size_type __n)
      { return *(this->_M_impl._M_start + __n); }
# 632 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      const_reference
      operator[](size_type __n) const
      { return *(this->_M_impl._M_start + __n); }

    public:

      void
      _M_range_check(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range(("vector::_M_range_check"));
      }

    public:
# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 675 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      const_reference
      at(size_type __n) const
      {
 _M_range_check(__n);
 return (*this)[__n];
      }





      reference
      front()
      { return *begin(); }





      const_reference
      front() const
      { return *begin(); }





      reference
      back()
      { return *(end() - 1); }





      const_reference
      back() const
      { return *(end() - 1); }
# 721 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      pointer
      data()
      { return pointer(this->_M_impl._M_start); }

      const_pointer
      data() const
      { return const_pointer(this->_M_impl._M_start); }
# 740 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      void
      push_back(const value_type& __x)
      {
 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
   {
     this->_M_impl.construct(this->_M_impl._M_finish, __x);
     ++this->_M_impl._M_finish;
   }
 else
   _M_insert_aux(end(), __x);
      }
# 771 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      void
      pop_back()
      {
 --this->_M_impl._M_finish;
 this->_M_impl.destroy(this->_M_impl._M_finish);
      }
# 807 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 857 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      void
      insert(iterator __position, size_type __n, const value_type& __x)
      { _M_fill_insert(__position, __n, __x); }
# 875 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      template<typename _InputIterator>
        void
        insert(iterator __position, _InputIterator __first,
        _InputIterator __last)
        {

   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_insert_dispatch(__position, __first, __last, _Integral());
 }
# 900 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      iterator
      erase(iterator __position);
# 921 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 933 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      void
      swap(vector& __x)
      {
 std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
 std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
 std::swap(this->_M_impl._M_end_of_storage,
    __x._M_impl._M_end_of_storage);



 std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
          __x._M_get_Tp_allocator());
      }







      void
      clear()
      { _M_erase_at_end(this->_M_impl._M_start); }

    public:




      template<typename _ForwardIterator>
        pointer
        _M_allocate_and_copy(size_type __n,
        _ForwardIterator __first, _ForwardIterator __last)
        {
   pointer __result = this->_M_allocate(__n);
   try
     {
       std::__uninitialized_copy_a(__first, __last, __result,
       _M_get_Tp_allocator());
       return __result;
     }
   catch(...)
     {
       _M_deallocate(__result, __n);
       throw;
     }
 }
# 988 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      template<typename _Integer>
        void
        _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
        {
   this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
   this->_M_impl._M_end_of_storage =
     this->_M_impl._M_start + static_cast<size_type>(__n);
   _M_fill_initialize(static_cast<size_type>(__n), __value);
 }


      template<typename _InputIterator>
        void
        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
          __false_type)
        {
   typedef typename std::iterator_traits<_InputIterator>::
     iterator_category _IterCategory;
   _M_range_initialize(__first, __last, _IterCategory());
 }


      template<typename _InputIterator>
        void
        _M_range_initialize(_InputIterator __first,
       _InputIterator __last, std::input_iterator_tag)
        {
   for (; __first != __last; ++__first)
     push_back(*__first);
 }


      template<typename _ForwardIterator>
        void
        _M_range_initialize(_ForwardIterator __first,
       _ForwardIterator __last, std::forward_iterator_tag)
        {
   const size_type __n = std::distance(__first, __last);
   this->_M_impl._M_start = this->_M_allocate(__n);
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
   this->_M_impl._M_finish =
     std::__uninitialized_copy_a(__first, __last,
     this->_M_impl._M_start,
     _M_get_Tp_allocator());
 }



      void
      _M_fill_initialize(size_type __n, const value_type& __value)
      {
 std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
          _M_get_Tp_allocator());
 this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
      }
# 1052 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      template<typename _Integer>
        void
        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
        { _M_fill_assign(__n, __val); }


      template<typename _InputIterator>
        void
        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
      __false_type)
        {
   typedef typename std::iterator_traits<_InputIterator>::
     iterator_category _IterCategory;
   _M_assign_aux(__first, __last, _IterCategory());
 }


      template<typename _InputIterator>
        void
        _M_assign_aux(_InputIterator __first, _InputIterator __last,
        std::input_iterator_tag);


      template<typename _ForwardIterator>
        void
        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
        std::forward_iterator_tag);



      void
      _M_fill_assign(size_type __n, const value_type& __val);
# 1092 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
      template<typename _Integer>
        void
        _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
      __true_type)
        { _M_fill_insert(__pos, __n, __val); }


      template<typename _InputIterator>
        void
        _M_insert_dispatch(iterator __pos, _InputIterator __first,
      _InputIterator __last, __false_type)
        {
   typedef typename std::iterator_traits<_InputIterator>::
     iterator_category _IterCategory;
   _M_range_insert(__pos, __first, __last, _IterCategory());
 }


      template<typename _InputIterator>
        void
        _M_range_insert(iterator __pos, _InputIterator __first,
   _InputIterator __last, std::input_iterator_tag);


      template<typename _ForwardIterator>
        void
        _M_range_insert(iterator __pos, _ForwardIterator __first,
   _ForwardIterator __last, std::forward_iterator_tag);



      void
      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);



      void
      _M_insert_aux(iterator __position, const value_type& __x);







      size_type
      _M_check_len(size_type __n, const char* __s) const
      {
 if (max_size() - size() < __n)
   __throw_length_error((__s));

 const size_type __len = size() + std::max(size(), __n);
 return (__len < size() || __len > max_size()) ? max_size() : __len;
      }





      void
      _M_erase_at_end(pointer __pos)
      {
 std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
 this->_M_impl._M_finish = __pos;
      }
    };
# 1170 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return (__x.size() == __y.size()
       && std::equal(__x.begin(), __x.end(), __y.begin())); }
# 1187 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return std::lexicographical_compare(__x.begin(), __x.end(),
       __y.begin(), __y.end()); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Tp, typename _Alloc>
    inline void
    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
    { __x.swap(__y); }

}
# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 1 3
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  typedef unsigned long _Bit_type;
  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };

  struct _Bit_reference
  {
    _Bit_type * _M_p;
    _Bit_type _M_mask;

    _Bit_reference(_Bit_type * __x, _Bit_type __y)
    : _M_p(__x), _M_mask(__y) { }

    _Bit_reference() : _M_p(0), _M_mask(0) { }

    operator bool() const
    { return !!(*_M_p & _M_mask); }

    _Bit_reference&
    operator=(bool __x)
    {
      if (__x)
 *_M_p |= _M_mask;
      else
 *_M_p &= ~_M_mask;
      return *this;
    }

    _Bit_reference&
    operator=(const _Bit_reference& __x)
    { return *this = bool(__x); }

    bool
    operator==(const _Bit_reference& __x) const
    { return bool(*this) == bool(__x); }

    bool
    operator<(const _Bit_reference& __x) const
    { return !bool(*this) && bool(__x); }

    void
    flip()
    { *_M_p ^= _M_mask; }
  };

  struct _Bit_iterator_base
  : public std::iterator<std::random_access_iterator_tag, bool>
  {
    _Bit_type * _M_p;
    unsigned int _M_offset;

    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
    : _M_p(__x), _M_offset(__y) { }

    void
    _M_bump_up()
    {
      if (_M_offset++ == int(_S_word_bit) - 1)
 {
   _M_offset = 0;
   ++_M_p;
 }
    }

    void
    _M_bump_down()
    {
      if (_M_offset-- == 0)
 {
   _M_offset = int(_S_word_bit) - 1;
   --_M_p;
 }
    }

    void
    _M_incr(ptrdiff_t __i)
    {
      difference_type __n = __i + _M_offset;
      _M_p += __n / int(_S_word_bit);
      __n = __n % int(_S_word_bit);
      if (__n < 0)
 {
   __n += int(_S_word_bit);
   --_M_p;
 }
      _M_offset = static_cast<unsigned int>(__n);
    }

    bool
    operator==(const _Bit_iterator_base& __i) const
    { return _M_p == __i._M_p && _M_offset == __i._M_offset; }

    bool
    operator<(const _Bit_iterator_base& __i) const
    {
      return _M_p < __i._M_p
      || (_M_p == __i._M_p && _M_offset < __i._M_offset);
    }

    bool
    operator!=(const _Bit_iterator_base& __i) const
    { return !(*this == __i); }

    bool
    operator>(const _Bit_iterator_base& __i) const
    { return __i < *this; }

    bool
    operator<=(const _Bit_iterator_base& __i) const
    { return !(__i < *this); }

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

  inline ptrdiff_t
  operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
  {
    return (int(_S_word_bit) * (__x._M_p - __y._M_p)
     + __x._M_offset - __y._M_offset);
  }

  struct _Bit_iterator : public _Bit_iterator_base
  {
    typedef _Bit_reference reference;
    typedef _Bit_reference* pointer;
    typedef _Bit_iterator iterator;

    _Bit_iterator() : _Bit_iterator_base(0, 0) { }

    _Bit_iterator(_Bit_type * __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) { }

    reference
    operator*() const
    { return reference(_M_p, 1UL << _M_offset); }

    iterator&
    operator++()
    {
      _M_bump_up();
      return *this;
    }

    iterator
    operator++(int)
    {
      iterator __tmp = *this;
      _M_bump_up();
      return __tmp;
    }

    iterator&
    operator--()
    {
      _M_bump_down();
      return *this;
    }

    iterator
    operator--(int)
    {
      iterator __tmp = *this;
      _M_bump_down();
      return __tmp;
    }

    iterator&
    operator+=(difference_type __i)
    {
      _M_incr(__i);
      return *this;
    }

    iterator&
    operator-=(difference_type __i)
    {
      *this += -__i;
      return *this;
    }

    iterator
    operator+(difference_type __i) const
    {
      iterator __tmp = *this;
      return __tmp += __i;
    }

    iterator
    operator-(difference_type __i) const
    {
      iterator __tmp = *this;
      return __tmp -= __i;
    }

    reference
    operator[](difference_type __i) const
    { return *(*this + __i); }
  };

  inline _Bit_iterator
  operator+(ptrdiff_t __n, const _Bit_iterator& __x)
  { return __x + __n; }

  struct _Bit_const_iterator : public _Bit_iterator_base
  {
    typedef bool reference;
    typedef bool const_reference;
    typedef const bool* pointer;
    typedef _Bit_const_iterator const_iterator;

    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }

    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) { }

    _Bit_const_iterator(const _Bit_iterator& __x)
    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }

    const_reference
    operator*() const
    { return _Bit_reference(_M_p, 1UL << _M_offset); }

    const_iterator&
    operator++()
    {
      _M_bump_up();
      return *this;
    }

    const_iterator
    operator++(int)
    {
      const_iterator __tmp = *this;
      _M_bump_up();
      return __tmp;
    }

    const_iterator&
    operator--()
    {
      _M_bump_down();
      return *this;
    }

    const_iterator
    operator--(int)
    {
      const_iterator __tmp = *this;
      _M_bump_down();
      return __tmp;
    }

    const_iterator&
    operator+=(difference_type __i)
    {
      _M_incr(__i);
      return *this;
    }

    const_iterator&
    operator-=(difference_type __i)
    {
      *this += -__i;
      return *this;
    }

    const_iterator
    operator+(difference_type __i) const
    {
      const_iterator __tmp = *this;
      return __tmp += __i;
    }

    const_iterator
    operator-(difference_type __i) const
    {
      const_iterator __tmp = *this;
      return __tmp -= __i;
    }

    const_reference
    operator[](difference_type __i) const
    { return *(*this + __i); }
  };

  inline _Bit_const_iterator
  operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
  { return __x + __n; }

  inline void
  __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
  {
    for (; __first != __last; ++__first)
      *__first = __x;
  }

  inline void
  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
  {
    if (__first._M_p != __last._M_p)
      {
 std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
 __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
 __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
      }
    else
      __fill_bvector(__first, __last, __x);
  }

  template<typename _Alloc>
    struct _Bvector_base
    {
      typedef typename _Alloc::template rebind<_Bit_type>::other
        _Bit_alloc_type;

      struct _Bvector_impl
      : public _Bit_alloc_type
      {
 _Bit_iterator _M_start;
 _Bit_iterator _M_finish;
 _Bit_type* _M_end_of_storage;

 _Bvector_impl()
 : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0)
 { }

 _Bvector_impl(const _Bit_alloc_type& __a)
 : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
 { }
      };

    public:
      typedef _Alloc allocator_type;

      _Bit_alloc_type&
      _M_get_Bit_allocator()
      { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }

      const _Bit_alloc_type&
      _M_get_Bit_allocator() const
      { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }

      allocator_type
      get_allocator() const
      { return allocator_type(_M_get_Bit_allocator()); }

      _Bvector_base()
      : _M_impl() { }

      _Bvector_base(const allocator_type& __a)
      : _M_impl(__a) { }
# 429 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
      ~_Bvector_base()
      { this->_M_deallocate(); }

    public:
      _Bvector_impl _M_impl;

      _Bit_type*
      _M_allocate(size_t __n)
      { return _M_impl.allocate((__n + int(_S_word_bit) - 1)
    / int(_S_word_bit)); }

      void
      _M_deallocate()
      {
 if (_M_impl._M_start._M_p)
   _M_impl.deallocate(_M_impl._M_start._M_p,
        _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
      }
    };

}




namespace std __attribute__ ((__visibility__ ("default"))) {
# 473 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
template<typename _Alloc>
  class vector<bool, _Alloc> : public _Bvector_base<_Alloc>
  {
    typedef _Bvector_base<_Alloc> _Base;





  public:
    typedef bool value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef _Bit_reference reference;
    typedef bool const_reference;
    typedef _Bit_reference* pointer;
    typedef const bool* const_pointer;
    typedef _Bit_iterator iterator;
    typedef _Bit_const_iterator const_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef _Alloc allocator_type;

    allocator_type get_allocator() const
    { return _Base::get_allocator(); }

  public:
    using _Base::_M_allocate;
    using _Base::_M_deallocate;
    using _Base::_M_get_Bit_allocator;

  public:
    vector()
    : _Base() { }

    explicit
    vector(const allocator_type& __a)
    : _Base(__a) { }

    explicit
    vector(size_type __n, const bool& __value = bool(),
    const allocator_type& __a = allocator_type())
    : _Base(__a)
    {
      _M_initialize(__n);
      std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
  __value ? ~0 : 0);
    }

    vector(const vector& __x)
    : _Base(__x._M_get_Bit_allocator())
    {
      _M_initialize(__x.size());
      _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
    }
# 542 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
    template<typename _InputIterator>
      vector(_InputIterator __first, _InputIterator __last,
      const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
 _M_initialize_dispatch(__first, __last, _Integral());
      }

    ~vector() { }

    vector&
    operator=(const vector& __x)
    {
      if (&__x == this)
 return *this;
      if (__x.size() > capacity())
 {
   this->_M_deallocate();
   _M_initialize(__x.size());
 }
      this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
      begin());
      return *this;
    }
# 591 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
    void
    assign(size_type __n, const bool& __x)
    { _M_fill_assign(__n, __x); }

    template<typename _InputIterator>
      void
      assign(_InputIterator __first, _InputIterator __last)
      {
 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
 _M_assign_dispatch(__first, __last, _Integral());
      }







    iterator
    begin()
    { return this->_M_impl._M_start; }

    const_iterator
    begin() const
    { return this->_M_impl._M_start; }

    iterator
    end()
    { return this->_M_impl._M_finish; }

    const_iterator
    end() const
    { return this->_M_impl._M_finish; }

    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()); }
# 659 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
    size_type
    size() const
    { return size_type(end() - begin()); }

    size_type
    max_size() const
    {
      const size_type __isize =
 __gnu_cxx::__numeric_traits<difference_type>::__max
 - int(_S_word_bit) + 1;
      const size_type __asize = _M_get_Bit_allocator().max_size();
      return (__asize <= __isize / int(_S_word_bit)
       ? __asize * int(_S_word_bit) : __isize);
    }

    size_type
    capacity() const
    { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
         - begin()); }

    bool
    empty() const
    { return begin() == end(); }

    reference
    operator[](size_type __n)
    {
      return *iterator(this->_M_impl._M_start._M_p
         + __n / int(_S_word_bit), __n % int(_S_word_bit));
    }

    const_reference
    operator[](size_type __n) const
    {
      return *const_iterator(this->_M_impl._M_start._M_p
        + __n / int(_S_word_bit), __n % int(_S_word_bit));
    }

  public:
    void
    _M_range_check(size_type __n) const
    {
      if (__n >= this->size())
        __throw_out_of_range(("vector<bool>::_M_range_check"));
    }

  public:
    reference
    at(size_type __n)
    { _M_range_check(__n); return (*this)[__n]; }

    const_reference
    at(size_type __n) const
    { _M_range_check(__n); return (*this)[__n]; }

    void
    reserve(size_type __n);

    reference
    front()
    { return *begin(); }

    const_reference
    front() const
    { return *begin(); }

    reference
    back()
    { return *(end() - 1); }

    const_reference
    back() const
    { return *(end() - 1); }






    void
    data() { }

    void
    push_back(bool __x)
    {
      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
        *this->_M_impl._M_finish++ = __x;
      else
        _M_insert_aux(end(), __x);
    }

    void
    swap(vector& __x)
    {
      std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
      std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
      std::swap(this->_M_impl._M_end_of_storage,
  __x._M_impl._M_end_of_storage);



      std::__alloc_swap<typename _Base::_Bit_alloc_type>::
 _S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
    }


    static void
    swap(reference __x, reference __y)
    {
      bool __tmp = __x;
      __x = __y;
      __y = __tmp;
    }

    iterator
    insert(iterator __position, const bool& __x = bool())
    {
      const difference_type __n = __position - begin();
      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
   && __position == end())
        *this->_M_impl._M_finish++ = __x;
      else
        _M_insert_aux(__position, __x);
      return begin() + __n;
    }

    template<typename _InputIterator>
      void
      insert(iterator __position,
      _InputIterator __first, _InputIterator __last)
      {
 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
 _M_insert_dispatch(__position, __first, __last, _Integral());
      }

    void
    insert(iterator __position, size_type __n, const bool& __x)
    { _M_fill_insert(__position, __n, __x); }






    void
    pop_back()
    { --this->_M_impl._M_finish; }

    iterator
    erase(iterator __position)
    {
      if (__position + 1 != end())
        std::copy(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      return __position;
    }

    iterator
    erase(iterator __first, iterator __last)
    {
      _M_erase_at_end(std::copy(__last, end(), __first));
      return __first;
    }

    void
    resize(size_type __new_size, bool __x = bool())
    {
      if (__new_size < size())
        _M_erase_at_end(begin() + difference_type(__new_size));
      else
        insert(end(), __new_size - size(), __x);
    }







    void
    flip()
    {
      for (_Bit_type * __p = this->_M_impl._M_start._M_p;
    __p != this->_M_impl._M_end_of_storage; ++__p)
        *__p = ~*__p;
    }

    void
    clear()
    { _M_erase_at_end(begin()); }


  public:

    iterator
    _M_copy_aligned(const_iterator __first, const_iterator __last,
      iterator __result)
    {
      _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
      return std::copy(const_iterator(__last._M_p, 0), __last,
         iterator(__q, 0));
    }

    void
    _M_initialize(size_type __n)
    {
      _Bit_type* __q = this->_M_allocate(__n);
      this->_M_impl._M_end_of_storage = (__q
      + ((__n + int(_S_word_bit) - 1)
         / int(_S_word_bit)));
      this->_M_impl._M_start = iterator(__q, 0);
      this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
    }





    template<typename _Integer>
      void
      _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
      {
 _M_initialize(static_cast<size_type>(__n));
 std::fill(this->_M_impl._M_start._M_p,
    this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
      }

    template<typename _InputIterator>
      void
      _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
        __false_type)
      { _M_initialize_range(__first, __last,
       std::__iterator_category(__first)); }

    template<typename _InputIterator>
      void
      _M_initialize_range(_InputIterator __first, _InputIterator __last,
     std::input_iterator_tag)
      {
 for (; __first != __last; ++__first)
   push_back(*__first);
      }

    template<typename _ForwardIterator>
      void
      _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
     std::forward_iterator_tag)
      {
 const size_type __n = std::distance(__first, __last);
 _M_initialize(__n);
 std::copy(__first, __last, this->_M_impl._M_start);
      }



    template<typename _Integer>
      void
      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
      { _M_fill_assign(__n, __val); }

    template<class _InputIterator>
      void
      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
    __false_type)
      { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }

    void
    _M_fill_assign(size_t __n, bool __x)
    {
      if (__n > size())
 {
   std::fill(this->_M_impl._M_start._M_p,
      this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
   insert(end(), __n - size(), __x);
 }
      else
 {
   _M_erase_at_end(begin() + __n);
   std::fill(this->_M_impl._M_start._M_p,
      this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
 }
    }

    template<typename _InputIterator>
      void
      _M_assign_aux(_InputIterator __first, _InputIterator __last,
      std::input_iterator_tag)
      {
 iterator __cur = begin();
 for (; __first != __last && __cur != end(); ++__cur, ++__first)
   *__cur = *__first;
 if (__first == __last)
   _M_erase_at_end(__cur);
 else
   insert(end(), __first, __last);
      }

    template<typename _ForwardIterator>
      void
      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
      std::forward_iterator_tag)
      {
 const size_type __len = std::distance(__first, __last);
 if (__len < size())
   _M_erase_at_end(std::copy(__first, __last, begin()));
 else
   {
     _ForwardIterator __mid = __first;
     std::advance(__mid, size());
     std::copy(__first, __mid, begin());
     insert(end(), __mid, __last);
   }
      }





    template<typename _Integer>
      void
      _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
    __true_type)
      { _M_fill_insert(__pos, __n, __x); }

    template<typename _InputIterator>
      void
      _M_insert_dispatch(iterator __pos,
    _InputIterator __first, _InputIterator __last,
    __false_type)
      { _M_insert_range(__pos, __first, __last,
   std::__iterator_category(__first)); }

    void
    _M_fill_insert(iterator __position, size_type __n, bool __x);

    template<typename _InputIterator>
      void
      _M_insert_range(iterator __pos, _InputIterator __first,
        _InputIterator __last, std::input_iterator_tag)
      {
 for (; __first != __last; ++__first)
   {
     __pos = insert(__pos, *__first);
     ++__pos;
   }
      }

    template<typename _ForwardIterator>
      void
      _M_insert_range(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag);

    void
    _M_insert_aux(iterator __position, bool __x);

    size_type
    _M_check_len(size_type __n, const char* __s) const
    {
      if (max_size() - size() < __n)
 __throw_length_error((__s));

      const size_type __len = size() + std::max(size(), __n);
      return (__len < size() || __len > max_size()) ? max_size() : __len;
    }

    void
    _M_erase_at_end(iterator __pos)
    { this->_M_impl._M_finish = __pos; }
  };

}
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/vector.tcc" 1 3
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/vector.tcc" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    reserve(size_type __n)
    {
      if (__n > this->max_size())
 __throw_length_error(("vector::reserve"));
      if (this->capacity() < __n)
 {
   const size_type __old_size = size();
   pointer __tmp = _M_allocate_and_copy(__n,
   (this->_M_impl._M_start),
   (this->_M_impl._M_finish));
   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
   _M_get_Tp_allocator());
   _M_deallocate(this->_M_impl._M_start,
   this->_M_impl._M_end_of_storage
   - this->_M_impl._M_start);
   this->_M_impl._M_start = __tmp;
   this->_M_impl._M_finish = __tmp + __old_size;
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
 }
    }
# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/vector.tcc" 3
  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    insert(iterator __position, const value_type& __x)
    {
      const size_type __n = __position - begin();
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
   && __position == end())
 {
   this->_M_impl.construct(this->_M_impl._M_finish, __x);
   ++this->_M_impl._M_finish;
 }
      else
 {
# 126 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/vector.tcc" 3
     _M_insert_aux(__position, __x);
 }
      return iterator(this->_M_impl._M_start + __n);
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    erase(iterator __position)
    {
      if (__position + 1 != end())
 std::copy(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      this->_M_impl.destroy(this->_M_impl._M_finish);
      return __position;
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    erase(iterator __first, iterator __last)
    {
      if (__last != end())
 std::copy(__last, end(), __first);
      _M_erase_at_end(__first.base() + (end() - __last));
      return __first;
    }

  template<typename _Tp, typename _Alloc>
    vector<_Tp, _Alloc>&
    vector<_Tp, _Alloc>::
    operator=(const vector<_Tp, _Alloc>& __x)
    {
      if (&__x != this)
 {
   const size_type __xlen = __x.size();
   if (__xlen > capacity())
     {
       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
         __x.end());
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
       _M_deallocate(this->_M_impl._M_start,
       this->_M_impl._M_end_of_storage
       - this->_M_impl._M_start);
       this->_M_impl._M_start = __tmp;
       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
     }
   else if (size() >= __xlen)
     {
       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
       end(), _M_get_Tp_allocator());
     }
   else
     {
       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
   this->_M_impl._M_start);
       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
       __x._M_impl._M_finish,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
     }
   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
 }
      return *this;
    }

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_fill_assign(size_t __n, const value_type& __val)
    {
      if (__n > capacity())
 {
   vector __tmp(__n, __val, _M_get_Tp_allocator());
   __tmp.swap(*this);
 }
      else if (__n > size())
 {
   std::fill(begin(), end(), __val);
   std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
     __n - size(), __val,
     _M_get_Tp_allocator());
   this->_M_impl._M_finish += __n - size();
 }
      else
        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
    }

  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      void
      vector<_Tp, _Alloc>::
      _M_assign_aux(_InputIterator __first, _InputIterator __last,
      std::input_iterator_tag)
      {
 pointer __cur(this->_M_impl._M_start);
 for (; __first != __last && __cur != this->_M_impl._M_finish;
      ++__cur, ++__first)
   *__cur = *__first;
 if (__first == __last)
   _M_erase_at_end(__cur);
 else
   insert(end(), __first, __last);
      }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      void
      vector<_Tp, _Alloc>::
      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
      std::forward_iterator_tag)
      {
 const size_type __len = std::distance(__first, __last);

 if (__len > capacity())
   {
     pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
     std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
     _M_get_Tp_allocator());
     _M_deallocate(this->_M_impl._M_start,
     this->_M_impl._M_end_of_storage
     - this->_M_impl._M_start);
     this->_M_impl._M_start = __tmp;
     this->_M_impl._M_finish = this->_M_impl._M_start + __len;
     this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
   }
 else if (size() >= __len)
   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
 else
   {
     _ForwardIterator __mid = __first;
     std::advance(__mid, size());
     std::copy(__first, __mid, this->_M_impl._M_start);
     this->_M_impl._M_finish =
       std::__uninitialized_copy_a(__mid, __last,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
   }
      }
# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/vector.tcc" 3
  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_insert_aux(iterator __position, const _Tp& __x)

    {
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
 {
   this->_M_impl.construct(this->_M_impl._M_finish,
      (*(this->_M_impl._M_finish - 1))
             );
   ++this->_M_impl._M_finish;

   _Tp __x_copy = __x;

   std::copy_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)

                                  ;

   *__position = __x_copy;



 }
      else
 {
   const size_type __len =
     _M_check_len(size_type(1), "vector::_M_insert_aux");
   const size_type __elems_before = __position - begin();
   pointer __new_start(this->_M_allocate(__len));
   pointer __new_finish(__new_start);
   try
     {




       this->_M_impl.construct(__new_start + __elems_before,



                               __x);

       __new_finish = 0;

       __new_finish =
  std::__uninitialized_move_a(this->_M_impl._M_start,
         __position.base(), __new_start,
         _M_get_Tp_allocator());
       ++__new_finish;

       __new_finish =
  std::__uninitialized_move_a(__position.base(),
         this->_M_impl._M_finish,
         __new_finish,
         _M_get_Tp_allocator());
     }
          catch(...)
     {
       if (!__new_finish)
  this->_M_impl.destroy(__new_start + __elems_before);
       else
  std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
       _M_deallocate(__new_start, __len);
       throw;
     }
   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
   _M_get_Tp_allocator());
   _M_deallocate(this->_M_impl._M_start,
   this->_M_impl._M_end_of_storage
   - this->_M_impl._M_start);
   this->_M_impl._M_start = __new_start;
   this->_M_impl._M_finish = __new_finish;
   this->_M_impl._M_end_of_storage = __new_start + __len;
 }
    }

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
    {
      if (__n != 0)
 {
   if (size_type(this->_M_impl._M_end_of_storage
   - this->_M_impl._M_finish) >= __n)
     {
       value_type __x_copy = __x;
       const size_type __elems_after = end() - __position;
       pointer __old_finish(this->_M_impl._M_finish);
       if (__elems_after > __n)
  {
    std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
           this->_M_impl._M_finish,
           this->_M_impl._M_finish,
           _M_get_Tp_allocator());
    this->_M_impl._M_finish += __n;
    std::copy_backward(__position.base(), __old_finish - __n, __old_finish)
                                        ;
    std::fill(__position.base(), __position.base() + __n,
       __x_copy);
  }
       else
  {
    std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
      __n - __elems_after,
      __x_copy,
      _M_get_Tp_allocator());
    this->_M_impl._M_finish += __n - __elems_after;
    std::__uninitialized_move_a(__position.base(), __old_finish,
           this->_M_impl._M_finish,
           _M_get_Tp_allocator());
    this->_M_impl._M_finish += __elems_after;
    std::fill(__position.base(), __old_finish, __x_copy);
  }
     }
   else
     {
       const size_type __len =
  _M_check_len(__n, "vector::_M_fill_insert");
       const size_type __elems_before = __position - begin();
       pointer __new_start(this->_M_allocate(__len));
       pointer __new_finish(__new_start);
       try
  {

    std::__uninitialized_fill_n_a(__new_start + __elems_before,
      __n, __x,
      _M_get_Tp_allocator());
    __new_finish = 0;

    __new_finish =
      std::__uninitialized_move_a(this->_M_impl._M_start,
      __position.base(),
      __new_start,
      _M_get_Tp_allocator());
    __new_finish += __n;

    __new_finish =
      std::__uninitialized_move_a(__position.base(),
      this->_M_impl._M_finish,
      __new_finish,
      _M_get_Tp_allocator());
  }
       catch(...)
  {
    if (!__new_finish)
      std::_Destroy(__new_start + __elems_before,
      __new_start + __elems_before + __n,
      _M_get_Tp_allocator());
    else
      std::_Destroy(__new_start, __new_finish,
      _M_get_Tp_allocator());
    _M_deallocate(__new_start, __len);
    throw;
  }
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
       _M_deallocate(this->_M_impl._M_start,
       this->_M_impl._M_end_of_storage
       - this->_M_impl._M_start);
       this->_M_impl._M_start = __new_start;
       this->_M_impl._M_finish = __new_finish;
       this->_M_impl._M_end_of_storage = __new_start + __len;
     }
 }
    }

  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      void
      vector<_Tp, _Alloc>::
      _M_range_insert(iterator __pos, _InputIterator __first,
        _InputIterator __last, std::input_iterator_tag)
      {
 for (; __first != __last; ++__first)
   {
     __pos = insert(__pos, *__first);
     ++__pos;
   }
      }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      void
      vector<_Tp, _Alloc>::
      _M_range_insert(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag)
      {
 if (__first != __last)
   {
     const size_type __n = std::distance(__first, __last);
     if (size_type(this->_M_impl._M_end_of_storage
     - this->_M_impl._M_finish) >= __n)
       {
  const size_type __elems_after = end() - __position;
  pointer __old_finish(this->_M_impl._M_finish);
  if (__elems_after > __n)
    {
      std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
      this->_M_impl._M_finish,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __n;
      std::copy_backward(__position.base(), __old_finish - __n, __old_finish)
                                          ;
      std::copy(__first, __last, __position);
    }
  else
    {
      _ForwardIterator __mid = __first;
      std::advance(__mid, __elems_after);
      std::__uninitialized_copy_a(__mid, __last,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __n - __elems_after;
      std::__uninitialized_move_a(__position.base(),
      __old_finish,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __elems_after;
      std::copy(__first, __mid, __position);
    }
       }
     else
       {
  const size_type __len =
    _M_check_len(__n, "vector::_M_range_insert");
  pointer __new_start(this->_M_allocate(__len));
  pointer __new_finish(__new_start);
  try
    {
      __new_finish =
        std::__uninitialized_move_a(this->_M_impl._M_start,
        __position.base(),
        __new_start,
        _M_get_Tp_allocator());
      __new_finish =
        std::__uninitialized_copy_a(__first, __last,
        __new_finish,
        _M_get_Tp_allocator());
      __new_finish =
        std::__uninitialized_move_a(__position.base(),
        this->_M_impl._M_finish,
        __new_finish,
        _M_get_Tp_allocator());
    }
  catch(...)
    {
      std::_Destroy(__new_start, __new_finish,
      _M_get_Tp_allocator());
      _M_deallocate(__new_start, __len);
      throw;
    }
  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
         _M_get_Tp_allocator());
  _M_deallocate(this->_M_impl._M_start,
         this->_M_impl._M_end_of_storage
         - this->_M_impl._M_start);
  this->_M_impl._M_start = __new_start;
  this->_M_impl._M_finish = __new_finish;
  this->_M_impl._M_end_of_storage = __new_start + __len;
       }
   }
      }




  template<typename _Alloc>
    void
    vector<bool, _Alloc>::
    reserve(size_type __n)
    {
      if (__n > this->max_size())
 __throw_length_error(("vector::reserve"));
      if (this->capacity() < __n)
 {
   _Bit_type* __q = this->_M_allocate(__n);
   this->_M_impl._M_finish = _M_copy_aligned(begin(), end(),
          iterator(__q, 0));
   this->_M_deallocate();
   this->_M_impl._M_start = iterator(__q, 0);
   this->_M_impl._M_end_of_storage = (__q + (__n + int(_S_word_bit) - 1)
          / int(_S_word_bit));
 }
    }

  template<typename _Alloc>
    void
    vector<bool, _Alloc>::
    _M_fill_insert(iterator __position, size_type __n, bool __x)
    {
      if (__n == 0)
 return;
      if (capacity() - size() >= __n)
 {
   std::copy_backward(__position, end(),
        this->_M_impl._M_finish + difference_type(__n));
   std::fill(__position, __position + difference_type(__n), __x);
   this->_M_impl._M_finish += difference_type(__n);
 }
      else
 {
   const size_type __len =
     _M_check_len(__n, "vector<bool>::_M_fill_insert");
   _Bit_type * __q = this->_M_allocate(__len);
   iterator __i = _M_copy_aligned(begin(), __position,
      iterator(__q, 0));
   std::fill(__i, __i + difference_type(__n), __x);
   this->_M_impl._M_finish = std::copy(__position, end(),
           __i + difference_type(__n));
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = (__q + ((__len
           + int(_S_word_bit) - 1)
          / int(_S_word_bit)));
   this->_M_impl._M_start = iterator(__q, 0);
 }
    }

  template<typename _Alloc>
    template<typename _ForwardIterator>
      void
      vector<bool, _Alloc>::
      _M_insert_range(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag)
      {
 if (__first != __last)
   {
     size_type __n = std::distance(__first, __last);
     if (capacity() - size() >= __n)
       {
  std::copy_backward(__position, end(),
       this->_M_impl._M_finish
       + difference_type(__n));
  std::copy(__first, __last, __position);
  this->_M_impl._M_finish += difference_type(__n);
       }
     else
       {
  const size_type __len =
    _M_check_len(__n, "vector<bool>::_M_insert_range");
  _Bit_type * __q = this->_M_allocate(__len);
  iterator __i = _M_copy_aligned(begin(), __position,
            iterator(__q, 0));
  __i = std::copy(__first, __last, __i);
  this->_M_impl._M_finish = std::copy(__position, end(), __i);
  this->_M_deallocate();
  this->_M_impl._M_end_of_storage = (__q
         + ((__len
             + int(_S_word_bit) - 1)
            / int(_S_word_bit)));
  this->_M_impl._M_start = iterator(__q, 0);
       }
   }
      }

  template<typename _Alloc>
    void
    vector<bool, _Alloc>::
    _M_insert_aux(iterator __position, bool __x)
    {
      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
 {
   std::copy_backward(__position, this->_M_impl._M_finish,
        this->_M_impl._M_finish + 1);
   *__position = __x;
   ++this->_M_impl._M_finish;
 }
      else
 {
   const size_type __len =
     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
   _Bit_type * __q = this->_M_allocate(__len);
   iterator __i = _M_copy_aligned(begin(), __position,
      iterator(__q, 0));
   *__i++ = __x;
   this->_M_impl._M_finish = std::copy(__position, end(), __i);
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = (__q + ((__len
           + int(_S_word_bit) - 1)
          / int(_S_word_bit)));
   this->_M_impl._M_start = iterator(__q, 0);
 }
    }

}
# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 2 3
# 53 "/usr/include/qt4/QtCore/qvector.h" 2

# 1 "/usr/include/stdlib.h" 1 3 4
# 33 "/usr/include/stdlib.h" 3 4
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 34 "/usr/include/stdlib.h" 2 3 4

extern "C" {






# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 43 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 67 "/usr/include/bits/waitstatus.h" 3 4
union wait
  {
    int w_status;
    struct
      {

 unsigned int __w_termsig:7;
 unsigned int __w_coredump:1;
 unsigned int __w_retcode:8;
 unsigned int:16;







      } __wait_terminated;
    struct
      {

 unsigned int __w_stopval:8;
 unsigned int __w_stopsig:8;
 unsigned int:16;






      } __wait_stopped;
  };
# 44 "/usr/include/stdlib.h" 2 3 4
# 96 "/usr/include/stdlib.h" 3 4


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



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







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


# 140 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw () __attribute__ ((__warn_unused_result__));




extern double atof (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern int atoi (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern long int atol (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





__extension__ extern long long int atoll (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern double strtod (__const char *__restrict __nptr,
        char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern float strtof (__const char *__restrict __nptr,
       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern long double strtold (__const char *__restrict __nptr,
       char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern long int strtol (__const char *__restrict __nptr,
   char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern unsigned long int strtoul (__const char *__restrict __nptr,
      char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));




__extension__
extern long long int strtoq (__const char *__restrict __nptr,
        char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
           char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





__extension__
extern long long int strtoll (__const char *__restrict __nptr,
         char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
     char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

# 240 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (__const char *__restrict __nptr,
     char **__restrict __endptr, int __base,
     __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));

extern unsigned long int strtoul_l (__const char *__restrict __nptr,
        char **__restrict __endptr,
        int __base, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));

__extension__
extern long long int strtoll_l (__const char *__restrict __nptr,
    char **__restrict __endptr, int __base,
    __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));

__extension__
extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
       char **__restrict __endptr,
       int __base, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));

extern double strtod_l (__const char *__restrict __nptr,
   char **__restrict __endptr, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));

extern float strtof_l (__const char *__restrict __nptr,
         char **__restrict __endptr, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));

extern long double strtold_l (__const char *__restrict __nptr,
         char **__restrict __endptr,
         __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));





extern __inline __attribute__ ((__gnu_inline__)) double
atof (__const char *__nptr) throw ()
{
  return strtod (__nptr, (char **) __null);
}
extern __inline __attribute__ ((__gnu_inline__)) int
atoi (__const char *__nptr) throw ()
{
  return (int) strtol (__nptr, (char **) __null, 10);
}
extern __inline __attribute__ ((__gnu_inline__)) long int
atol (__const char *__nptr) throw ()
{
  return strtol (__nptr, (char **) __null, 10);
}




__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
atoll (__const char *__nptr) throw ()
{
  return strtoll (__nptr, (char **) __null, 10);
}

# 311 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw () __attribute__ ((__warn_unused_result__));


extern long int a64l (__const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));




# 1 "/usr/include/sys/types.h" 1 3 4
# 29 "/usr/include/sys/types.h" 3 4
extern "C" {





typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;




typedef __loff_t loff_t;



typedef __ino_t ino_t;






typedef __ino64_t ino64_t;




typedef __dev_t dev_t;
# 72 "/usr/include/sys/types.h" 3 4
typedef __mode_t mode_t;




typedef __nlink_t nlink_t;
# 105 "/usr/include/sys/types.h" 3 4
typedef __id_t id_t;
# 116 "/usr/include/sys/types.h" 3 4
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;
# 141 "/usr/include/sys/types.h" 3 4
typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 148 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 195 "/usr/include/sys/types.h" 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 220 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/sys/select.h" 1 3 4
# 31 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/bits/select.h" 1 3 4
# 23 "/usr/include/bits/select.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 24 "/usr/include/bits/select.h" 2 3 4
# 32 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 35 "/usr/include/sys/select.h" 2 3 4
# 46 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/bits/time.h" 1 3 4
# 69 "/usr/include/bits/time.h" 3 4
struct timeval
  {
    __time_t tv_sec;
    __suseconds_t tv_usec;
  };
# 47 "/usr/include/sys/select.h" 2 3 4
# 55 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;
# 67 "/usr/include/sys/select.h" 3 4
typedef struct
  {



    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];





  } fd_set;






typedef __fd_mask fd_mask;
# 99 "/usr/include/sys/select.h" 3 4
extern "C" {
# 109 "/usr/include/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
     fd_set *__restrict __writefds,
     fd_set *__restrict __exceptfds,
     struct timeval *__restrict __timeout);
# 121 "/usr/include/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
      fd_set *__restrict __writefds,
      fd_set *__restrict __exceptfds,
      const struct timespec *__restrict __timeout,
      const __sigset_t *__restrict __sigmask);


}
# 221 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 30 "/usr/include/sys/sysmacros.h" 3 4
__extension__
extern unsigned int gnu_dev_major (unsigned long long int __dev)
     throw ();
__extension__
extern unsigned int gnu_dev_minor (unsigned long long int __dev)
     throw ();
__extension__
extern unsigned long long int gnu_dev_makedev (unsigned int __major,
            unsigned int __minor)
     throw ();


__extension__ extern __inline __attribute__ ((__gnu_inline__)) unsigned int
gnu_dev_major (unsigned long long int __dev) throw ()
{
  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
}

__extension__ extern __inline __attribute__ ((__gnu_inline__)) unsigned int
gnu_dev_minor (unsigned long long int __dev) throw ()
{
  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
}

__extension__ extern __inline __attribute__ ((__gnu_inline__)) unsigned long long int
gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
{
  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
   | (((unsigned long long int) (__minor & ~0xff)) << 12)
   | (((unsigned long long int) (__major & ~0xfff)) << 32));
}
# 224 "/usr/include/sys/types.h" 2 3 4




typedef __blksize_t blksize_t;






typedef __blkcnt_t blkcnt_t;



typedef __fsblkcnt_t fsblkcnt_t;



typedef __fsfilcnt_t fsfilcnt_t;
# 262 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
# 273 "/usr/include/sys/types.h" 3 4
}
# 321 "/usr/include/stdlib.h" 2 3 4






extern long int random (void) throw ();


extern void srandom (unsigned int __seed) throw ();





extern char *initstate (unsigned int __seed, char *__statebuf,
   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));



extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int srandom_r (unsigned int __seed, struct random_data *__buf)
     throw () __attribute__ ((__nonnull__ (2)));

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
   size_t __statelen,
   struct random_data *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (2, 4)));

extern int setstate_r (char *__restrict __statebuf,
         struct random_data *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (1, 2)));






extern int rand (void) throw ();

extern void srand (unsigned int __seed) throw ();




extern int rand_r (unsigned int *__seed) throw ();







extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));


extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
     throw () __attribute__ ((__nonnull__ (1)));


extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
     throw () __attribute__ ((__nonnull__ (1)));


extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
     throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));





struct drand48_data
  {
    unsigned short int __x[3];
    unsigned short int __old_x[3];
    unsigned short int __c;
    unsigned short int __init;
    unsigned long long int __a;
  };


extern int drand48_r (struct drand48_data *__restrict __buffer,
        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int lrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int mrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     throw () __attribute__ ((__nonnull__ (2)));

extern int seed48_r (unsigned short int __seed16v[3],
       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int lcong48_r (unsigned short int __param[7],
        struct drand48_data *__buffer)
     throw () __attribute__ ((__nonnull__ (1, 2)));









extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));

extern void *calloc (size_t __nmemb, size_t __size)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));










extern void *realloc (void *__ptr, size_t __size)
     throw () __attribute__ ((__warn_unused_result__));

extern void free (void *__ptr) throw ();




extern void cfree (void *__ptr) throw ();



# 1 "/usr/include/alloca.h" 1 3 4
# 25 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 26 "/usr/include/alloca.h" 2 3 4

extern "C" {





extern void *alloca (size_t __size) throw ();





}
# 498 "/usr/include/stdlib.h" 2 3 4




extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));




extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));




extern void abort (void) throw () __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));






extern "C++" int at_quick_exit (void (*__func) (void))
     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));









extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     throw () __attribute__ ((__nonnull__ (1)));






extern void exit (int __status) throw () __attribute__ ((__noreturn__));







extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));







extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));






extern char *getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));




extern char *__secure_getenv (__const char *__name)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));





extern int setenv (__const char *__name, __const char *__value, int __replace)
     throw () __attribute__ ((__nonnull__ (2)));


extern int unsetenv (__const char *__name) throw ();






extern int clearenv (void) throw ();
# 604 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 615 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 625 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 637 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 647 "/usr/include/stdlib.h" 3 4
extern int mkstemps64 (char *__template, int __suffixlen)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 658 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 669 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 679 "/usr/include/stdlib.h" 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 689 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 701 "/usr/include/stdlib.h" 3 4
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));









extern int system (__const char *__command) __attribute__ ((__warn_unused_result__));






extern char *canonicalize_file_name (__const char *__name)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 729 "/usr/include/stdlib.h" 3 4
extern char *realpath (__const char *__restrict __name,
         char *__restrict __resolved) throw () __attribute__ ((__warn_unused_result__));






typedef int (*__compar_fn_t) (__const void *, __const void *);


typedef __compar_fn_t comparison_fn_t;



typedef int (*__compar_d_fn_t) (__const void *, __const void *, void *);





extern void *bsearch (__const void *__key, __const void *__base,
        size_t __nmemb, size_t __size, __compar_fn_t __compar)
     __attribute__ ((__nonnull__ (1, 2, 5))) __attribute__ ((__warn_unused_result__));



extern void qsort (void *__base, size_t __nmemb, size_t __size,
     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));

extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
       __compar_d_fn_t __compar, void *__arg)
  __attribute__ ((__nonnull__ (1, 4)));




extern int abs (int __x) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
extern long int labs (long int __x) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));



__extension__ extern long long int llabs (long long int __x)
     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));







extern div_t div (int __numer, int __denom)
     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
extern ldiv_t ldiv (long int __numer, long int __denom)
     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));




__extension__ extern lldiv_t lldiv (long long int __numer,
        long long int __denom)
     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));

# 802 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));




extern char *gcvt (double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));




extern char *qecvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
extern char *qfcvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));

extern int qecvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (3, 4, 5)));







extern int mblen (__const char *__s, size_t __n) throw () __attribute__ ((__warn_unused_result__));


extern int mbtowc (wchar_t *__restrict __pwc,
     __const char *__restrict __s, size_t __n) throw () __attribute__ ((__warn_unused_result__));


extern int wctomb (char *__s, wchar_t __wchar) throw () __attribute__ ((__warn_unused_result__));



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
   __const char *__restrict __s, size_t __n) throw ();

extern size_t wcstombs (char *__restrict __s,
   __const wchar_t *__restrict __pwcs, size_t __n)
     throw ();








extern int rpmatch (__const char *__response) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 890 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
        char *__const *__restrict __tokens,
        char **__restrict __valuep)
     throw () __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__));





extern void setkey (__const char *__key) throw () __attribute__ ((__nonnull__ (1)));







extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__));







extern int grantpt (int __fd) throw ();



extern int unlockpt (int __fd) throw ();




extern char *ptsname (int __fd) throw () __attribute__ ((__warn_unused_result__));






extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2)));


extern int getpt (void);






extern int getloadavg (double __loadavg[], int __nelem)
     throw () __attribute__ ((__nonnull__ (1)));





# 1 "/usr/include/bits/stdlib.h" 1 3 4
# 24 "/usr/include/bits/stdlib.h" 3 4
extern char *__realpath_chk (__const char *__restrict __name,
        char *__restrict __resolved,
        size_t __resolvedlen) throw () __attribute__ ((__warn_unused_result__));
extern char *__realpath_alias (__const char *__restrict __name, char *__restrict __resolved) throw () __asm__ ("" "realpath")

                                                 __attribute__ ((__warn_unused_result__));
extern char *__realpath_chk_warn (__const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) throw () __asm__ ("" "__realpath_chk")


                                                __attribute__ ((__warn_unused_result__))
     __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer")))
                                      ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
realpath (__const char *__restrict __name, char *__restrict __resolved) throw ()
{
  if (__builtin_object_size (__resolved, 2 > 1) != (size_t) -1)
    {




      return __realpath_chk (__name, __resolved, __builtin_object_size (__resolved, 2 > 1));
    }

  return __realpath_alias (__name, __resolved);
}


extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen,
       size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ptsname_r")

     __attribute__ ((__nonnull__ (2)));
extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ptsname_r_chk")


     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf")))
                   ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
ptsname_r (int __fd, char *__buf, size_t __buflen) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __ptsname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __ptsname_r_alias (__fd, __buf, __buflen);
}


extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen)
  throw () __attribute__ ((__warn_unused_result__));
extern int __wctomb_alias (char *__s, wchar_t __wchar) throw () __asm__ ("" "wctomb")
              __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) int
wctomb (char *__s, wchar_t __wchar) throw ()
{







  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
    return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 2 > 1));
  return __wctomb_alias (__s, __wchar);
}


extern size_t __mbstowcs_chk (wchar_t *__restrict __dst,
         __const char *__restrict __src,
         size_t __len, size_t __dstlen) throw ();
extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len) throw () __asm__ ("" "mbstowcs")


                                  ;
extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__mbstowcs_chk")



     __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
mbstowcs (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __mbstowcs_chk (__dst, __src, __len,
          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));

      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
 return __mbstowcs_chk_warn (__dst, __src, __len,
         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
    }
  return __mbstowcs_alias (__dst, __src, __len);
}


extern size_t __wcstombs_chk (char *__restrict __dst,
         __const wchar_t *__restrict __src,
         size_t __len, size_t __dstlen) throw ();
extern size_t __wcstombs_alias (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len) throw () __asm__ ("" "wcstombs")


                                  ;
extern size_t __wcstombs_chk_warn (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__wcstombs_chk")



     __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len")));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
wcstombs (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __wcstombs_chk (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
      if (__len > __builtin_object_size (__dst, 2 > 1))
 return __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
    }
  return __wcstombs_alias (__dst, __src, __len);
}
# 950 "/usr/include/stdlib.h" 2 3 4
# 958 "/usr/include/stdlib.h" 3 4
}
# 55 "/usr/include/qt4/QtCore/qvector.h" 2






typedef QtValidLicenseForCoreModule QtCoreModule;

struct QVectorData
{
    QBasicAtomicInt ref;
    int alloc;
    int size;






    uint sharable : 1;
    uint capacity : 1;
    uint reserved : 30;


    static QVectorData shared_null;



    static QVectorData *malloc(int sizeofTypedData, int size, int sizeofT, QVectorData *init);
    static QVectorData *allocate(int size, int alignment);
    static QVectorData *reallocate(QVectorData *old, int newsize, int oldsize, int alignment);
    static void free(QVectorData *data, int alignment);
    static int grow(int sizeofTypedData, int size, int sizeofT, bool excessive);
};

template <typename T>
struct QVectorTypedData : private QVectorData
{

    T array[1];

    static inline void free(QVectorTypedData<T> *x, int alignment) { QVectorData::free(static_cast<QVectorData *>(x), alignment); }
};

class QRegion;

template <typename T>
class QVector
{
    typedef QVectorTypedData<T> Data;
    union {
        QVectorData *d;



        Data *p;

    };

public:
    inline QVector() : d(&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(p); }
    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); d->capacity = 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; }

    inline T *data() { detach(); return p->array; }
    inline const T *data() const { return p->array; }
    inline const T *constData() const { return p->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;
# 230 "/usr/include/qt4/QtCore/qvector.h"
    typedef T* iterator;
    typedef const T* const_iterator;

    inline iterator begin() { detach(); return p->array; }
    inline const_iterator begin() const { return p->array; }
    inline const_iterator constBegin() const { return p->array; }
    inline iterator end() { detach(); return p->array + d->size; }
    inline const_iterator end() const { return p->array + d->size; }
    inline const_iterator constEnd() const { return p->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() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",246) : qt_noop()); return *begin(); }
    inline const T &first() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",247) : qt_noop()); return *begin(); }
    inline T& last() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",248) : qt_noop()); return *(end()-1); }
    inline const T &last() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",249) : qt_noop()); return *(end()-1); }
    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
    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() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",269) : qt_noop()); erase(end()-1); }
    void pop_front() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",270) : qt_noop()); 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:
    friend class QRegion;

    void detach_helper();
    QVectorData *malloc(int alloc);
    void realloc(int size, int alloc);
    void free(Data *d);
    int sizeOfTypedData() {


        return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
    }
    inline int alignOfTypedData() const
    {

        return qMax<int>(sizeof(void*), __alignof__(Data));



    }
};

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); if (d->ref == 1) d->capacity = 1; }
template <typename T>
void QVector<T>::resize(int asize)
{ realloc(asize, (asize > d->alloc || (!d->capacity && asize < d->size && asize < (d->alloc >> 1))) ?
          QVectorData::grow(sizeOfTypedData(), 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
{ ((!(i >= 0 && i < d->size)) ? qt_assert_x("QVector<T>::at", "index out of range","/usr/include/qt4/QtCore/qvector.h",338) : qt_noop());
  return p->array[i]; }
template <typename T>
inline const T &QVector<T>::operator[](int i) const
{ ((!(i >= 0 && i < d->size)) ? qt_assert_x("QVector<T>::operator[]", "index out of range","/usr/include/qt4/QtCore/qvector.h",342) : qt_noop());
  return p->array[i]; }
template <typename T>
inline T &QVector<T>::operator[](int i)
{ ((!(i >= 0 && i < d->size)) ? qt_assert_x("QVector<T>::operator[]", "index out of range","/usr/include/qt4/QtCore/qvector.h",346) : qt_noop());
  return data()[i]; }
template <typename T>
inline void QVector<T>::insert(int i, const T &t)
{ ((!(i >= 0 && i <= d->size)) ? qt_assert_x("QVector<T>::insert", "index out of range","/usr/include/qt4/QtCore/qvector.h",350) : qt_noop());
  insert(begin() + i, 1, t); }
template <typename T>
inline void QVector<T>::insert(int i, int n, const T &t)
{ ((!(i >= 0 && i <= d->size)) ? qt_assert_x("QVector<T>::insert", "index out of range","/usr/include/qt4/QtCore/qvector.h",354) : qt_noop());
  insert(begin() + i, n, t); }
template <typename T>
inline void QVector<T>::remove(int i, int n)
{ ((!(i >= 0 && n >= 0 && i + n <= d->size)) ? qt_assert_x("QVector<T>::remove", "index out of range","/usr/include/qt4/QtCore/qvector.h",358) : qt_noop());
  erase(begin() + i, begin() + i + n); }
template <typename T>
inline void QVector<T>::remove(int i)
{ ((!(i >= 0 && i < d->size)) ? qt_assert_x("QVector<T>::remove", "index out of range","/usr/include/qt4/QtCore/qvector.h",362) : qt_noop());
  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)
{
    ((!(i >= 0 && i < d->size)) ? qt_assert_x("QVector<T>::replace", "index out of range","/usr/include/qt4/QtCore/qvector.h",371) : qt_noop());
    const T copy(t);
    data()[i] = copy;
}

template <typename T>
QVector<T> &QVector<T>::operator=(const QVector<T> &v)
{
    v.d->ref.ref();
    if (!d->ref.deref())
        free(p);
    d = v.d;
    if (!d->sharable)
        detach_helper();
    return *this;
}

template <typename T>
inline QVectorData *QVector<T>::malloc(int aalloc)
{
    QVectorData *vectordata = QVectorData::allocate(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData());
    do { if (!(vectordata)) qBadAlloc(); } while (0);
    return vectordata;
}

template <typename T>
QVector<T>::QVector(int asize)
{
    d = malloc(asize);
    d->ref = 1;
    d->alloc = d->size = asize;
    d->sharable = true;
    d->capacity = false;
    if (QTypeInfo<T>::isComplex) {
        T* b = p->array;
        T* i = p->array + d->size;
        while (i != b)
            new (--i) T;
    } else {
        qMemSet(p->array, 0, asize * sizeof(T));
    }
}

template <typename T>
QVector<T>::QVector(int asize, const T &t)
{
    d = malloc(asize);
    d->ref = 1;
    d->alloc = d->size = asize;
    d->sharable = true;
    d->capacity = false;
    T* i = p->array + d->size;
    while (i != p->array)
        new (--i) T(t);
}

template <typename T>
void QVector<T>::free(Data *x)
{
    if (QTypeInfo<T>::isComplex) {
        T* b = x->array;
        union { QVectorData *d; Data *p; } u;
        u.p = x;
        T* i = b + u.d->size;
        while (i-- != b)
             i->~T();
    }
    x->free(x, alignOfTypedData());
}

template <typename T>
void QVector<T>::realloc(int asize, int aalloc)
{
    ((!(asize <= aalloc)) ? qt_assert("asize <= aalloc","/usr/include/qt4/QtCore/qvector.h",444) : qt_noop());
    T *pOld;
    T *pNew;
    union { QVectorData *d; Data *p; } x;
    x.d = d;

    if (QTypeInfo<T>::isComplex && asize < d->size && d->ref == 1 ) {


        pOld = p->array + d->size;
        pNew = p->array + asize;
        while (asize < d->size) {
            (--pOld)->~T();
            d->size--;
        }
    }

    if (aalloc != d->alloc || d->ref != 1) {

        if (QTypeInfo<T>::isStatic) {
            x.d = malloc(aalloc);
            do { if (!(x.p)) qBadAlloc(); } while (0);
            x.d->size = 0;
        } else if (d->ref != 1) {
            x.d = malloc(aalloc);
            do { if (!(x.p)) qBadAlloc(); } while (0);
            if (QTypeInfo<T>::isComplex) {
                x.d->size = 0;
            } else {
                ::memcpy(x.p, p, sizeOfTypedData() + (qMin(aalloc, d->alloc) - 1) * sizeof(T));
                x.d->size = d->size;
            }
        } else {
            try {
                QVectorData *mem = QVectorData::reallocate(d, sizeOfTypedData() + (aalloc - 1) * sizeof(T),
                                                           sizeOfTypedData() + (d->alloc - 1) * sizeof(T), alignOfTypedData());
                do { if (!(mem)) qBadAlloc(); } while (0);
                x.d = d = mem;
                x.d->size = d->size;
            } catch (const std::bad_alloc &) {
                if (aalloc > d->alloc)
                    throw;
            }
        }
        x.d->ref = 1;
        x.d->alloc = aalloc;
        x.d->sharable = true;
        x.d->capacity = d->capacity;
        x.d->reserved = 0;
    }

    if (QTypeInfo<T>::isComplex) {
        try {
            pOld = p->array + x.d->size;
            pNew = x.p->array + x.d->size;

            const int toMove = qMin(asize, d->size);
            while (x.d->size < toMove) {
                new (pNew++) T(*pOld++);
                x.d->size++;
            }

            while (x.d->size < asize) {
                new (pNew++) T;
                x.d->size++;
            }
        } catch (...) {
            free(x.p);
            throw;
        }

    } else if (asize > x.d->size) {

        qMemSet(x.p->array + x.d->size, 0, (asize - x.d->size) * sizeof(T));
    }
    x.d->size = asize;

    if (d != x.d) {
        if (!d->ref.deref())
            free(p);
        d = x.d;
    }
}

template<typename T>
 T QVector<T>::value(int i) const
{
    if (i < 0 || i >= d->size) {
        return T();
    }
    return p->array[i];
}
template<typename T>
 T QVector<T>::value(int i, const T &defaultValue) const
{
    return ((i < 0 || i >= d->size) ? defaultValue : p->array[i]);
}

template <typename T>
void QVector<T>::append(const T &t)
{
    if (d->ref != 1 || d->size + 1 > d->alloc) {
        const T copy(t);
        realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + 1, sizeof(T),
                                           QTypeInfo<T>::isStatic));
        if (QTypeInfo<T>::isComplex)
            new (p->array + d->size) T(copy);
        else
            p->array[d->size] = copy;
    } else {
        if (QTypeInfo<T>::isComplex)
            new (p->array + d->size) T(t);
        else
            p->array[d->size] = t;
    }
    ++d->size;
}

template <typename T>
typename QVector<T>::iterator QVector<T>::insert(iterator before, size_type n, const T &t)
{
    int offset = int(before - p->array);
    if (n != 0) {
        const T copy(t);
        if (d->ref != 1 || d->size + n > d->alloc)
            realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + n, sizeof(T),
                                               QTypeInfo<T>::isStatic));
        if (QTypeInfo<T>::isStatic) {
            T *b = p->array + d->size;
            T *i = p->array + d->size + n;
            while (i != b)
                new (--i) T;
            i = p->array + d->size;
            T *j = i + n;
            b = p->array + offset;
            while (i != b)
                *--j = *--i;
            i = b+n;
            while (i != b)
                *--i = copy;
        } else {
            T *b = p->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 p->array + offset;
}

template <typename T>
typename QVector<T>::iterator QVector<T>::erase(iterator abegin, iterator aend)
{
    int f = int(abegin - p->array);
    int l = int(aend - p->array);
    int n = l - f;
    detach();
    if (QTypeInfo<T>::isComplex) {
        qCopy(p->array+l, p->array+d->size, p->array+f);
        T *i = p->array+d->size;
        T* b = p->array+d->size-n;
        while (i != b) {
            --i;
            i->~T();
        }
    } else {
        memmove(p->array + f, p->array + l, (d->size-l)*sizeof(T));
    }
    d->size -= n;
    return p->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 = p->array;
    T* i = b + d->size;
    T* j = v.p->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 = p->array + d->size;
        T *b = p->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 = p->array + newSize;
    T *i = l.p->array + l.d->size;
    T *b = l.p->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 = p->array + from - 1;
        T* e = p->array + d->size;
        while (++n != e)
            if (*n == t)
                return n - p->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 = p->array;
        T* n = p->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 = p->array;
    T* i = p->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 = p->array;
    T* i = p->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; typedef typename QVector<T>::const_iterator const_iterator; QVector<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(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() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qvector.h",769) : qt_noop()); return *n; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qvector.h",769) : qt_noop()); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } };
# 796 "/usr/include/qt4/QtCore/qvector.h"



# 46 "/usr/include/qt4/QtGui/qpolygon.h" 2







typedef QtValidLicenseForGuiModule QtGuiModule;

class QMatrix;
class QTransform;
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);

    QPolygon translated(int dx, int dy) const;
    inline QPolygon translated(const QPoint &offset) const;

    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);

    bool containsPoint(const QPoint &pt, Qt::FillRule fillRule) const;

    QPolygon united(const QPolygon &r) const;
    QPolygon intersected(const QPolygon &r) const;
    QPolygon subtracted(const QPolygon &r) const;
};

inline QPolygon::QPolygon(int asize) : QVector<QPoint>(asize) {}


 QDebug operator<<(QDebug, const QPolygon &);






 QDataStream &operator<<(QDataStream &stream, const QPolygon &polygon);
 QDataStream &operator>>(QDataStream &stream, QPolygon &polygon);






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()); }

inline QPolygon QPolygon::translated(const QPoint &offset) const
{ return translated(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);

    inline QPolygonF translated(qreal dx, qreal dy) const;
    QPolygonF translated(const QPointF &offset) const;

    QPolygon toPolygon() const;

    bool isClosed() const { return !isEmpty() && first() == last(); }

    QRectF boundingRect() const;

    bool containsPoint(const QPointF &pt, Qt::FillRule fillRule) const;

    QPolygonF united(const QPolygonF &r) const;
    QPolygonF intersected(const QPolygonF &r) const;
    QPolygonF subtracted(const QPolygonF &r) 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)); }

inline QPolygonF QPolygonF::translated(qreal dx, qreal dy) const
{ return translated(QPointF(dx, dy)); }




# 46 "/usr/include/qt4/QtGui/qmatrix.h" 2
# 1 "/usr/include/qt4/QtGui/qregion.h" 1
# 53 "/usr/include/qt4/QtGui/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);



    QRegion(const QRegion &region);
    QRegion(const QBitmap &bitmap);
    ~QRegion();
    QRegion &operator=(const QRegion &);




    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 unite(const QRect &r) const;
    QRegion intersect(const QRegion &r) const;
    QRegion intersect(const QRect &r) const;
    QRegion subtract(const QRegion &r) const;
    QRegion eor(const QRegion &r) const;

    inline QRegion united(const QRegion &r) const { return unite(r); }
    inline QRegion united(const QRect &r) const { return unite(r); }
    inline QRegion intersected(const QRegion &r) const { return intersect(r); }
    inline QRegion intersected(const QRect &r) const { return intersect(r); }
    inline QRegion subtracted(const QRegion &r) const { return subtract(r); }
    inline QRegion xored(const QRegion &r) const { return eor(r); }

    bool intersects(const QRegion &r) const;
    bool intersects(const QRect &r) const;

    QRect boundingRect() const;
    QVector<QRect> rects() const;
    void setRects(const QRect *rect, int num);

    int numRects() const;

    int rectCount() const;

    const QRegion operator|(const QRegion &r) const;
    const QRegion operator+(const QRegion &r) const;
    const QRegion operator+(const QRect &r) const;
    const QRegion operator&(const QRegion &r) const;
    const QRegion operator&(const QRect &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 QRect &r);
    QRegion& operator&=(const QRegion &r);
    QRegion& operator&=(const QRect &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;
# 150 "/usr/include/qt4/QtGui/qregion.h"
    inline Region handle() const { if(!d->rgn) updateX11Region(); return d->rgn; }
# 172 "/usr/include/qt4/QtGui/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);




    friend bool qt_region_strictContains(const QRegion &region,
                                         const QRect &rect);
    friend struct QRegionPrivate;


    void exec(const QByteArray &ba, int ver = 0, QDataStream::ByteOrder byteOrder = QDataStream::BigEndian);

    struct QRegionData {
        QBasicAtomicInt 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 &);





# 47 "/usr/include/qt4/QtGui/qmatrix.h" 2

# 1 "/usr/include/qt4/QtCore/qline.h" 1
# 47 "/usr/include/qt4/QtCore/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 QLine translated(const QPoint &p) const;
    inline QLine translated(int dx, int dy) const;

    inline void setP1(const QPoint &p1);
    inline void setP2(const QPoint &p2);
    inline void setPoints(const QPoint &p1, const QPoint &p2);
    inline void setLine(int x1, int y1, int x2, int y2);

    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 QLine QLine::translated(const QPoint &p) const
{
    return QLine(pt1 + p, pt2 + p);
}

inline QLine QLine::translated(int adx, int ady) const
{
    return translated(QPoint(adx, ady));
}

inline void QLine::setP1(const QPoint &aP1)
{
    pt1 = aP1;
}

inline void QLine::setP2(const QPoint &aP2)
{
    pt2 = aP2;
}

inline void QLine::setPoints(const QPoint &aP1, const QPoint &aP2)
{
    pt1 = aP1;
    pt2 = aP2;
}

inline void QLine::setLine(int aX1, int aY1, int aX2, int aY2)
{
    pt1 = QPoint(aX1, aY1);
    pt2 = QPoint(aX2, aY2);
}

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()) { }

    static QLineF fromPolar(qreal length, qreal angle);

    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);

    qreal angle() const;
    void setAngle(qreal angle);

    qreal angleTo(const QLineF &l) const;

    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 QLineF translated(const QPointF &p) const;
    inline QLineF translated(qreal dx, qreal dy) const;

    inline void setP1(const QPointF &p1);
    inline void setP2(const QPointF &p2);
    inline void setPoints(const QPointF &p1, const QPointF &p2);
    inline void setLine(qreal x1, qreal y1, qreal x2, qreal y2);

    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 QLineF QLineF::translated(const QPointF &p) const
{
    return QLineF(pt1 + p, pt2 + p);
}

inline QLineF QLineF::translated(qreal adx, qreal ady) const
{
    return translated(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 void QLineF::setP1(const QPointF &aP1)
{
    pt1 = aP1;
}

inline void QLineF::setP2(const QPointF &aP2)
{
    pt2 = aP2;
}

inline void QLineF::setPoints(const QPointF &aP1, const QPointF &aP2)
{
    pt1 = aP1;
    pt2 = aP2;
}

inline void QLineF::setLine(qreal aX1, qreal aY1, qreal aX2, qreal aY2)
{
    pt1 = QPointF(aX1, aY1);
    pt2 = QPointF(aX2, aY2);
}


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 &);





# 49 "/usr/include/qt4/QtGui/qmatrix.h" 2







typedef QtValidLicenseForGuiModule QtGuiModule;

class QPainterPath;
class QVariant;

class QMatrix
{
public:
    inline explicit QMatrix(Qt::Initialization) {}
    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 !qFuzzyIsNull(_m11*_m22 - _m12*_m21); }
    qreal determinant() const { return _m11*_m22 - _m12*_m21; }

    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 &);

    operator QVariant() const;







private:
    inline QMatrix(bool)
            : _m11(1.)
            , _m12(0.)
            , _m21(0.)
            , _m22(1.)
            , _dx(0.)
            , _dy(0.) {}
    inline QMatrix(qreal am11, qreal am12, qreal am21, qreal am22, qreal adx, qreal ady, bool)
            : _m11(am11)
            , _m12(am12)
            , _m21(am21)
            , _m22(am22)
            , _dx(adx)
            , _dy(ady) {}
    friend class QTransform;
    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 qFuzzyIsNull(_m11 - 1) && qFuzzyIsNull(_m22 - 1) && qFuzzyIsNull(_m12)
           && qFuzzyIsNull(_m21) && qFuzzyIsNull(_dx) && qFuzzyIsNull(_dy);
}

inline bool qFuzzyCompare(const QMatrix& m1, const QMatrix& m2)
{
    return qFuzzyCompare(m1.m11(), m2.m11())
        && qFuzzyCompare(m1.m12(), m2.m12())
        && qFuzzyCompare(m1.m21(), m2.m21())
        && qFuzzyCompare(m1.m22(), m2.m22())
        && qFuzzyCompare(m1.dx(), m2.dx())
        && qFuzzyCompare(m1.dy(), m2.dy());
}







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



 QDebug operator<<(QDebug, const QMatrix &);
# 202 "/usr/include/qt4/QtGui/qmatrix.h"



# 45 "/usr/include/qt4/QtGui/qtransform.h" 2
# 1 "/usr/include/qt4/QtGui/qpainterpath.h" 1
# 52 "/usr/include/qt4/QtGui/qpainterpath.h"




typedef QtValidLicenseForGuiModule QtGuiModule;

class QFont;
class QPainterPathPrivate;
struct QPainterPathPrivateDeleter;
class QPainterPathData;
class QPainterPathStrokerPrivate;
class QPolygonF;
class QRegion;
class QVectorPath;

class QPainterPath
{
public:
    enum ElementType {
        MoveToElement,
        LineToElement,
        CurveToElement,
        CurveToDataElement
    };

    class Element {
    public:
        qreal x;
        qreal y;
        ElementType type;

        bool isMoveTo() const { return type == MoveToElement; }
        bool isLineTo() const { return type == LineToElement; }
        bool isCurveTo() const { return type == CurveToElement; }

        operator QPointF () const { return QPointF(x, y); }

        bool operator==(const Element &e) const { return qFuzzyCompare(x, e.x)
            && qFuzzyCompare(y, e.y) && type == e.type; }
        inline bool operator!=(const Element &e) const { return !operator==(e); }
    };

    QPainterPath();
    explicit QPainterPath(const QPointF &startPoint);
    QPainterPath(const QPainterPath &other);
    QPainterPath &operator=(const QPainterPath &other);
    ~QPainterPath();

    void closeSubpath();

    void moveTo(const QPointF &p);
    inline void moveTo(qreal x, qreal y);

    void lineTo(const QPointF &p);
    inline void lineTo(qreal x, qreal y);

    void arcMoveTo(const QRectF &rect, qreal angle);
    inline void arcMoveTo(qreal x, qreal y, qreal w, qreal h, qreal angle);

    void arcTo(const QRectF &rect, qreal startAngle, qreal arcLength);
    inline void arcTo(qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength);

    void cubicTo(const QPointF &ctrlPt1, const QPointF &ctrlPt2, const QPointF &endPt);
    inline void cubicTo(qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y,
                        qreal endPtx, qreal endPty);
    void quadTo(const QPointF &ctrlPt, const QPointF &endPt);
    inline void quadTo(qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty);

    QPointF currentPosition() const;

    void addRect(const QRectF &rect);
    inline void addRect(qreal x, qreal y, qreal w, qreal h);
    void addEllipse(const QRectF &rect);
    inline void addEllipse(qreal x, qreal y, qreal w, qreal h);
    inline void addEllipse(const QPointF &center, qreal rx, qreal ry);
    void addPolygon(const QPolygonF &polygon);
    void addText(const QPointF &point, const QFont &f, const QString &text);
    inline void addText(qreal x, qreal y, const QFont &f, const QString &text);
    void addPath(const QPainterPath &path);
    void addRegion(const QRegion &region);

    void addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius,
                        Qt::SizeMode mode = Qt::AbsoluteSize);
    inline void addRoundedRect(qreal x, qreal y, qreal w, qreal h,
                               qreal xRadius, qreal yRadius,
                               Qt::SizeMode mode = Qt::AbsoluteSize);

    void addRoundRect(const QRectF &rect, int xRnd, int yRnd);
    inline void addRoundRect(qreal x, qreal y, qreal w, qreal h,
                             int xRnd, int yRnd);
    inline void addRoundRect(const QRectF &rect, int roundness);
    inline void addRoundRect(qreal x, qreal y, qreal w, qreal h,
                             int roundness);

    void connectPath(const QPainterPath &path);

    bool contains(const QPointF &pt) const;
    bool contains(const QRectF &rect) const;
    bool intersects(const QRectF &rect) const;

    void translate(qreal dx, qreal dy);
    inline void translate(const QPointF &offset);

    QPainterPath translated(qreal dx, qreal dy) const;
    inline QPainterPath translated(const QPointF &offset) const;

    QRectF boundingRect() const;
    QRectF controlPointRect() const;

    Qt::FillRule fillRule() const;
    void setFillRule(Qt::FillRule fillRule);

    inline bool isEmpty() const;

    QPainterPath toReversed() const;
    QList<QPolygonF> toSubpathPolygons(const QMatrix &matrix = QMatrix()) const;
    QList<QPolygonF> toFillPolygons(const QMatrix &matrix = QMatrix()) const;
    QPolygonF toFillPolygon(const QMatrix &matrix = QMatrix()) const;
    QList<QPolygonF> toSubpathPolygons(const QTransform &matrix) const;
    QList<QPolygonF> toFillPolygons(const QTransform &matrix) const;
    QPolygonF toFillPolygon(const QTransform &matrix) const;

    inline int elementCount() const;
    inline const QPainterPath::Element &elementAt(int i) const;
    inline void setElementPositionAt(int i, qreal x, qreal y);

    qreal length() const;
    qreal percentAtLength(qreal t) const;
    QPointF pointAtPercent(qreal t) const;
    qreal angleAtPercent(qreal t) const;
    qreal slopeAtPercent(qreal t) const;

    bool intersects(const QPainterPath &p) const;
    bool contains(const QPainterPath &p) const;
    QPainterPath united(const QPainterPath &r) const;
    QPainterPath intersected(const QPainterPath &r) const;
    QPainterPath subtracted(const QPainterPath &r) const;
    QPainterPath subtractedInverted(const QPainterPath &r) const;

    QPainterPath simplified() const;

    bool operator==(const QPainterPath &other) const;
    bool operator!=(const QPainterPath &other) const;

    QPainterPath operator&(const QPainterPath &other) const;
    QPainterPath operator|(const QPainterPath &other) const;
    QPainterPath operator+(const QPainterPath &other) const;
    QPainterPath operator-(const QPainterPath &other) const;
    QPainterPath &operator&=(const QPainterPath &other);
    QPainterPath &operator|=(const QPainterPath &other);
    QPainterPath &operator+=(const QPainterPath &other);
    QPainterPath &operator-=(const QPainterPath &other);

private:
    QScopedPointer<QPainterPathPrivate, QPainterPathPrivateDeleter> d_ptr;

    inline void ensureData() { if (!d_ptr) ensureData_helper(); }
    void ensureData_helper();
    inline void detach();
    void detach_helper();
    void setDirty(bool);
    void computeBoundingRect() const;
    void computeControlPointRect() const;

    QPainterPathData *d_func() const { return reinterpret_cast<QPainterPathData *>(d_ptr.data()); }

    friend class QPainterPathData;
    friend class QPainterPathStroker;
    friend class QPainterPathStrokerPrivate;
    friend class QMatrix;
    friend class QTransform;
    friend class QVectorPath;
    friend const QVectorPath &qtVectorPathForPath(const QPainterPath &);


    friend QDataStream &operator<<(QDataStream &, const QPainterPath &);
    friend QDataStream &operator>>(QDataStream &, QPainterPath &);

};

class QPainterPathPrivate
{
public:
    friend class QPainterPath;
    friend class QPainterPathData;
    friend class QPainterPathStroker;
    friend class QPainterPathStrokerPrivate;
    friend class QMatrix;
    friend class QTransform;
    friend class QVectorPath;
    friend struct QPainterPathPrivateDeleter;

    friend QDataStream &operator<<(QDataStream &, const QPainterPath &);
    friend QDataStream &operator>>(QDataStream &, QPainterPath &);

private:
    QAtomicInt ref;
    QVector<QPainterPath::Element> elements;
};

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


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


class QPainterPathStroker
{
    inline QPainterPathStrokerPrivate* d_func() { return reinterpret_cast<QPainterPathStrokerPrivate *>(qGetPtrHelper(d_ptr)); } inline const QPainterPathStrokerPrivate* d_func() const { return reinterpret_cast<const QPainterPathStrokerPrivate *>(qGetPtrHelper(d_ptr)); } friend class QPainterPathStrokerPrivate;
public:
    QPainterPathStroker();
    ~QPainterPathStroker();

    void setWidth(qreal width);
    qreal width() const;

    void setCapStyle(Qt::PenCapStyle style);
    Qt::PenCapStyle capStyle() const;

    void setJoinStyle(Qt::PenJoinStyle style);
    Qt::PenJoinStyle joinStyle() const;

    void setMiterLimit(qreal length);
    qreal miterLimit() const;

    void setCurveThreshold(qreal threshold);
    qreal curveThreshold() const;

    void setDashPattern(Qt::PenStyle);
    void setDashPattern(const QVector<qreal> &dashPattern);
    QVector<qreal> dashPattern() const;

    void setDashOffset(qreal offset);
    qreal dashOffset() const;

    QPainterPath createStroke(const QPainterPath &path) const;

private:
    friend class QX11PaintEngine;

    QScopedPointer<QPainterPathStrokerPrivate> d_ptr;
};

inline void QPainterPath::moveTo(qreal x, qreal y)
{
    moveTo(QPointF(x, y));
}

inline void QPainterPath::lineTo(qreal x, qreal y)
{
    lineTo(QPointF(x, y));
}

inline void QPainterPath::arcTo(qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength)
{
    arcTo(QRectF(x, y, w, h), startAngle, arcLength);
}

inline void QPainterPath::arcMoveTo(qreal x, qreal y, qreal w, qreal h, qreal angle)
{
    arcMoveTo(QRectF(x, y, w, h), angle);
}

inline void QPainterPath::cubicTo(qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y,
                                   qreal endPtx, qreal endPty)
{
    cubicTo(QPointF(ctrlPt1x, ctrlPt1y), QPointF(ctrlPt2x, ctrlPt2y),
            QPointF(endPtx, endPty));
}

inline void QPainterPath::quadTo(qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty)
{
    quadTo(QPointF(ctrlPtx, ctrlPty), QPointF(endPtx, endPty));
}

inline void QPainterPath::addEllipse(qreal x, qreal y, qreal w, qreal h)
{
    addEllipse(QRectF(x, y, w, h));
}

inline void QPainterPath::addEllipse(const QPointF &center, qreal rx, qreal ry)
{
    addEllipse(QRectF(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry));
}

inline void QPainterPath::addRect(qreal x, qreal y, qreal w, qreal h)
{
    addRect(QRectF(x, y, w, h));
}

inline void QPainterPath::addRoundedRect(qreal x, qreal y, qreal w, qreal h,
                                         qreal xRadius, qreal yRadius,
                                         Qt::SizeMode mode)
{
    addRoundedRect(QRectF(x, y, w, h), xRadius, yRadius, mode);
}

inline void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h,
                                       int xRnd, int yRnd)
{
    addRoundRect(QRectF(x, y, w, h), xRnd, yRnd);
}

inline void QPainterPath::addRoundRect(const QRectF &rect,
                                       int roundness)
{
    int xRnd = roundness;
    int yRnd = roundness;
    if (rect.width() > rect.height())
        xRnd = int(roundness * rect.height()/rect.width());
    else
        yRnd = int(roundness * rect.width()/rect.height());
    addRoundRect(rect, xRnd, yRnd);
}

inline void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h,
                                       int roundness)
{
    addRoundRect(QRectF(x, y, w, h), roundness);
}

inline void QPainterPath::addText(qreal x, qreal y, const QFont &f, const QString &text)
{
    addText(QPointF(x, y), f, text);
}

inline void QPainterPath::translate(const QPointF &offset)
{ translate(offset.x(), offset.y()); }

inline QPainterPath QPainterPath::translated(const QPointF &offset) const
{ return translated(offset.x(), offset.y()); }

inline bool QPainterPath::isEmpty() const
{
    return !d_ptr || (d_ptr->elements.size() == 1 && d_ptr->elements.first().type == MoveToElement);
}

inline int QPainterPath::elementCount() const
{
    return d_ptr ? d_ptr->elements.size() : 0;
}

inline const QPainterPath::Element &QPainterPath::elementAt(int i) const
{
    ((!(d_ptr)) ? qt_assert("d_ptr","/usr/include/qt4/QtGui/qpainterpath.h",397) : qt_noop());
    ((!(i >= 0 && i < elementCount())) ? qt_assert("i >= 0 && i < elementCount()","/usr/include/qt4/QtGui/qpainterpath.h",398) : qt_noop());
    return d_ptr->elements.at(i);
}

inline void QPainterPath::setElementPositionAt(int i, qreal x, qreal y)
{
    ((!(d_ptr)) ? qt_assert("d_ptr","/usr/include/qt4/QtGui/qpainterpath.h",404) : qt_noop());
    ((!(i >= 0 && i < elementCount())) ? qt_assert("i >= 0 && i < elementCount()","/usr/include/qt4/QtGui/qpainterpath.h",405) : qt_noop());
    detach();
    QPainterPath::Element &e = d_ptr->elements[i];
    e.x = x;
    e.y = y;
}


inline void QPainterPath::detach()
{
    if (d_ptr->ref != 1)
        detach_helper();
    setDirty(true);
}


 QDebug operator<<(QDebug, const QPainterPath &);





# 46 "/usr/include/qt4/QtGui/qtransform.h" 2
# 57 "/usr/include/qt4/QtGui/qtransform.h"




typedef QtValidLicenseForGuiModule QtGuiModule;

class QVariant;

class QTransform
{
   
public:
    enum TransformationType {
        TxNone = 0x00,
        TxTranslate = 0x01,
        TxScale = 0x02,
        TxRotate = 0x04,
        TxShear = 0x08,
        TxProject = 0x10
    };

    inline explicit QTransform(Qt::Initialization) : affine(Qt::Uninitialized) {}
    QTransform();
    QTransform(qreal h11, qreal h12, qreal h13,
               qreal h21, qreal h22, qreal h23,
               qreal h31, qreal h32, qreal h33 = 1.0);
    QTransform(qreal h11, qreal h12, qreal h21,
               qreal h22, qreal dx, qreal dy);
    explicit QTransform(const QMatrix &mtx);

    bool isAffine() const;
    bool isIdentity() const;
    bool isInvertible() const;
    bool isScaling() const;
    bool isRotating() const;
    bool isTranslating() const;

    TransformationType type() const;

    inline qreal determinant() const;
    qreal det() const;

    qreal m11() const;
    qreal m12() const;
    qreal m13() const;
    qreal m21() const;
    qreal m22() const;
    qreal m23() const;
    qreal m31() const;
    qreal m32() const;
    qreal m33() const;
    qreal dx() const;
    qreal dy() const;

    void setMatrix(qreal m11, qreal m12, qreal m13,
                   qreal m21, qreal m22, qreal m23,
                   qreal m31, qreal m32, qreal m33);

    QTransform inverted(bool *invertible = 0) const;
    QTransform adjoint() const;
    QTransform transposed() const;

    QTransform &translate(qreal dx, qreal dy);
    QTransform &scale(qreal sx, qreal sy);
    QTransform &shear(qreal sh, qreal sv);
    QTransform &rotate(qreal a, Qt::Axis axis = Qt::ZAxis);
    QTransform &rotateRadians(qreal a, Qt::Axis axis = Qt::ZAxis);

    static bool squareToQuad(const QPolygonF &square, QTransform &result);
    static bool quadToSquare(const QPolygonF &quad, QTransform &result);
    static bool quadToQuad(const QPolygonF &one,
                           const QPolygonF &two,
                           QTransform &result);

    bool operator==(const QTransform &) const;
    bool operator!=(const QTransform &) const;

    QTransform &operator*=(const QTransform &);
    QTransform operator*(const QTransform &o) const;

    QTransform &operator=(const QTransform &);

    operator QVariant() const;

    void reset();
    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;
    QRect mapRect(const QRect &) const;
    QRectF mapRect(const QRectF &) const;
    void map(int x, int y, int *tx, int *ty) const;
    void map(qreal x, qreal y, qreal *tx, qreal *ty) const;

    const QMatrix &toAffine() const;

    QTransform &operator*=(qreal div);
    QTransform &operator/=(qreal div);
    QTransform &operator+=(qreal div);
    QTransform &operator-=(qreal div);

    static QTransform fromTranslate(qreal dx, qreal dy);
    static QTransform fromScale(qreal dx, qreal dy);

private:
    inline QTransform(qreal h11, qreal h12, qreal h13,
                      qreal h21, qreal h22, qreal h23,
                      qreal h31, qreal h32, qreal h33, bool)
        : affine(h11, h12, h21, h22, h31, h32, true)
        , m_13(h13), m_23(h23), m_33(h33)
        , m_type(TxNone)
        , m_dirty(TxProject) {}
    inline QTransform(bool)
        : affine(true)
        , m_13(0), m_23(0), m_33(1)
        , m_type(TxNone)
        , m_dirty(TxNone) {}
    inline TransformationType inline_type() const;
    QMatrix affine;
    qreal m_13;
    qreal m_23;
    qreal m_33;

    mutable uint m_type : 5;
    mutable uint m_dirty : 5;

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


inline QTransform::TransformationType QTransform::inline_type() const
{
    if (m_dirty == TxNone)
        return static_cast<TransformationType>(m_type);
    return type();
}

inline bool QTransform::isAffine() const
{
    return inline_type() < TxProject;
}
inline bool QTransform::isIdentity() const
{
    return inline_type() == TxNone;
}

inline bool QTransform::isInvertible() const
{
    return !qFuzzyIsNull(determinant());
}

inline bool QTransform::isScaling() const
{
    return type() >= TxScale;
}
inline bool QTransform::isRotating() const
{
    return inline_type() >= TxRotate;
}

inline bool QTransform::isTranslating() const
{
    return inline_type() >= TxTranslate;
}

inline qreal QTransform::determinant() const
{
    return affine._m11*(m_33*affine._m22-affine._dy*m_23) -
        affine._m21*(m_33*affine._m12-affine._dy*m_13)+affine._dx*(m_23*affine._m12-affine._m22*m_13);
}
inline qreal QTransform::det() const
{
    return determinant();
}
inline qreal QTransform::m11() const
{
    return affine._m11;
}
inline qreal QTransform::m12() const
{
    return affine._m12;
}
inline qreal QTransform::m13() const
{
    return m_13;
}
inline qreal QTransform::m21() const
{
    return affine._m21;
}
inline qreal QTransform::m22() const
{
    return affine._m22;
}
inline qreal QTransform::m23() const
{
    return m_23;
}
inline qreal QTransform::m31() const
{
    return affine._dx;
}
inline qreal QTransform::m32() const
{
    return affine._dy;
}
inline qreal QTransform::m33() const
{
    return m_33;
}
inline qreal QTransform::dx() const
{
    return affine._dx;
}
inline qreal QTransform::dy() const
{
    return affine._dy;
}

inline QTransform &QTransform::operator*=(qreal num)
{
    if (num == 1.)
        return *this;
    affine._m11 *= num;
    affine._m12 *= num;
    m_13 *= num;
    affine._m21 *= num;
    affine._m22 *= num;
    m_23 *= num;
    affine._dx *= num;
    affine._dy *= num;
    m_33 *= num;
    m_dirty |= TxScale;
    return *this;
}
inline QTransform &QTransform::operator/=(qreal div)
{
    if (div == 0)
        return *this;
    div = 1/div;
    return operator*=(div);
}
inline QTransform &QTransform::operator+=(qreal num)
{
    if (num == 0)
        return *this;
    affine._m11 += num;
    affine._m12 += num;
    m_13 += num;
    affine._m21 += num;
    affine._m22 += num;
    m_23 += num;
    affine._dx += num;
    affine._dy += num;
    m_33 += num;
    m_dirty |= TxProject;
    return *this;
}
inline QTransform &QTransform::operator-=(qreal num)
{
    if (num == 0)
        return *this;
    affine._m11 -= num;
    affine._m12 -= num;
    m_13 -= num;
    affine._m21 -= num;
    affine._m22 -= num;
    m_23 -= num;
    affine._dx -= num;
    affine._dy -= num;
    m_33 -= num;
    m_dirty |= TxProject;
    return *this;
}

inline bool qFuzzyCompare(const QTransform& t1, const QTransform& t2)
{
    return qFuzzyCompare(t1.m11(), t2.m11())
        && qFuzzyCompare(t1.m12(), t2.m12())
        && qFuzzyCompare(t1.m13(), t2.m13())
        && qFuzzyCompare(t1.m21(), t2.m21())
        && qFuzzyCompare(t1.m22(), t2.m22())
        && qFuzzyCompare(t1.m23(), t2.m23())
        && qFuzzyCompare(t1.m31(), t2.m31())
        && qFuzzyCompare(t1.m32(), t2.m32())
        && qFuzzyCompare(t1.m33(), t2.m33());
}




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



 QDebug operator<<(QDebug, const QTransform &);




 inline QPoint operator*(const QPoint &p, const QTransform &m)
{ return m.map(p); }
 inline QPointF operator*(const QPointF &p, const QTransform &m)
{ return m.map(p); }
 inline QLineF operator*(const QLineF &l, const QTransform &m)
{ return m.map(l); }
 inline QLine operator*(const QLine &l, const QTransform &m)
{ return m.map(l); }
 inline QPolygon operator *(const QPolygon &a, const QTransform &m)
{ return m.map(a); }
 inline QPolygonF operator *(const QPolygonF &a, const QTransform &m)
{ return m.map(a); }
 inline QRegion operator *(const QRegion &r, const QTransform &m)
{ return m.map(r); }
 inline QPainterPath operator *(const QPainterPath &p, const QTransform &m)
{ return m.map(p); }

 inline QTransform operator *(const QTransform &a, qreal n)
{ QTransform t(a); t *= n; return t; }
 inline QTransform operator /(const QTransform &a, qreal n)
{ QTransform t(a); t /= n; return t; }
 inline QTransform operator +(const QTransform &a, qreal n)
{ QTransform t(a); t += n; return t; }
 inline QTransform operator -(const QTransform &a, qreal n)
{ QTransform t(a); t -= n; return t; }




# 46 "/usr/include/qt4/QtGui/qimage.h" 2










typedef QtValidLicenseForGuiModule QtGuiModule;

class QIODevice;
class QStringList;
class QMatrix;
class QTransform;
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; }
    inline bool operator!= (const QImageTextKeyLang &other) const
        { return !operator==(other); }
};



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,
        Format_RGB16,
        Format_ARGB8565_Premultiplied,
        Format_RGB666,
        Format_ARGB6666_Premultiplied,
        Format_RGB555,
        Format_ARGB8555_Premultiplied,
        Format_RGB888,
        Format_RGB444,
        Format_ARGB4444_Premultiplied,
# 119 "/usr/include/qt4/QtGui/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);
    QImage(const uchar *data, int width, int height, Format format);
    QImage(uchar *data, int width, int height, int bytesPerLine, Format format);
    QImage(const uchar *data, int width, int height, int bytesPerLine, 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 __attribute__ ((warn_unused_result));
    QImage convertToFormat(Format f, const QVector<QRgb> &colorTable, Qt::ImageConversionFlags flags = Qt::AutoColor) const __attribute__ ((warn_unused_result));

    int width() const;
    int height() const;
    QSize size() const;
    QRect rect() const;

    int depth() const;

    int numColors() const;

    int colorCount() const;

    QRgb color(int i) const;
    void setColor(int i, QRgb c);

    void setNumColors(int);

    void setColorCount(int);

    bool allGray() const;
    bool isGrayscale() const;

    uchar *bits();
    const uchar *bits() const;

    int numBytes() const;

    int byteCount() const;

    uchar *scanLine(int);
    const uchar *scanLine(int) const;
    int bytesPerLine() const;

    bool valid(int x, int y) const;
    bool valid(const QPoint &pt) const;

    int pixelIndex(int x, int y) const;
    int pixelIndex(const QPoint &pt) const;

    QRgb pixel(int x, int y) const;
    QRgb pixel(const QPoint &pt) const;

    void setPixel(int x, int y, uint index_or_rgb);
    void setPixel(const QPoint &pt, 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;

    QImage createMaskFromColor(QRgb color, Qt::MaskMode mode = Qt::MaskInColor) 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 transformed(const QTransform &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const;
    static QTransform trueMatrix(const QTransform &, 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=0, int quality=-1) const;
    bool save(QIODevice *device, const char* format=0, 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;
    qint64 cacheKey() 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&);
# 318 "/usr/include/qt4/QtGui/qimage.h"
public:
    virtual int metric(PaintDeviceMetric metric) const;

private:
    friend class QWSOnScreenSurface;
    QImageData *d;

    friend class QRasterPixmapData;
    friend class QPixmapCacheEntry;
    friend qint64 qt_image_id(const QImage &image);
    friend const QVector<QRgb> *qt_image_colortable(const QImage &image);

public:
    typedef QImageData * DataPtr;
    inline DataPtr &data_ptr() { return d; }
};

template <> inline bool qIsDetached<QImage>(QImage &t) { return t.isDetached(); } template <> inline void qSwap<QImage>(QImage &value1, QImage &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
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"; } };



 inline bool QImage::valid(const QPoint &pt) const { return valid(pt.x(), pt.y()); }
 inline int QImage::pixelIndex(const QPoint &pt) const { return pixelIndex(pt.x(), pt.y());}
 inline QRgb QImage::pixel(const QPoint &pt) const { return pixel(pt.x(), pt.y()); }
 inline void QImage::setPixel(const QPoint &pt, uint index_or_rgb) { setPixel(pt.x(), pt.y(), index_or_rgb); }




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










# 51 "/usr/include/qt4/QtGui/qpixmap.h" 2











typedef QtValidLicenseForGuiModule QtGuiModule;

class QImageWriter;
class QColor;
class QVariant;
class QX11Info;
class QPixmapData;

class QPixmap : public QPaintDevice
{
public:
    QPixmap();
    explicit QPixmap(QPixmapData *data);
    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;
    QBitmap createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode) 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);
    QPixmap transformed(const QTransform &, Qt::TransformationMode mode = Qt::FastTransformation) const;
    static QTransform trueMatrix(const QTransform &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 = 0, int quality = -1) const;
    bool save(QIODevice* device, const char* format = 0, int quality = -1) const;
# 170 "/usr/include/qt4/QtGui/qpixmap.h"
    inline QPixmap copy(int x, int y, int width, int height) const;
    QPixmap copy(const QRect &rect = QRect()) const;

    inline void scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed = 0);
    void scroll(int dx, int dy, const QRect &rect, QRegion *exposed = 0);

    int serialNumber() const;
    qint64 cacheKey() const;

    bool isDetached() const;
    void detach();

    bool isQBitmap() const;
# 197 "/usr/include/qt4/QtGui/qpixmap.h"
    enum ShareMode { ImplicitlyShared, ExplicitlyShared };

    static QPixmap fromX11Pixmap(Qt::HANDLE pixmap, ShareMode mode = ImplicitlyShared);
    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(); }

public:
    int metric(PaintDeviceMetric) const;
# 239 "/usr/include/qt4/QtGui/qpixmap.h"
private:
    QExplicitlySharedDataPointer<QPixmapData> data;

    bool doImageIO(QImageWriter *io, int quality) const;


    enum Type { PixmapType, BitmapType };
    QPixmap(const QSize &s, Type);
    void init(int, int, Type = PixmapType);

    QPixmap(const QSize &s, int type);
    void init(int, int, int);
    void deref();



   







    friend class QPixmapData;
    friend class QX11PixmapData;
    friend class QMacPixmapData;
    friend class QS60PixmapData;
    friend class QBitmap;
    friend class QPaintDevice;
    friend class QPainter;
    friend class QGLWidget;
    friend class QX11PaintEngine;
    friend class QCoreGraphicsPaintEngine;
    friend class QWidgetPrivate;
    friend class QRasterPaintEngine;
    friend class QRasterBuffer;
    friend class QPixmapCacheEntry;

    friend QDataStream &operator>>(QDataStream &, QPixmap &);

    friend qint64 qt_pixmap_id(const QPixmap &pixmap);

public:
    QPixmapData* pixmapData() const;

public:
    typedef QExplicitlySharedDataPointer<QPixmapData> DataPtr;
    inline DataPtr &data_ptr() { return data; }
};

template <> inline bool qIsDetached<QPixmap>(QPixmap &t) { return t.isDetached(); } template <> inline void qSwap<QPixmap>(QPixmap &value1, QPixmap &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }

inline QPixmap QPixmap::copy(int ax, int ay, int awidth, int aheight) const
{
    return copy(QRect(ax, ay, awidth, aheight));
}

inline void QPixmap::scroll(int dx, int dy, int ax, int ay, int awidth, int aheight, QRegion *exposed)
{
    scroll(dx, dy, QRect(ax, ay, awidth, aheight), exposed);
}

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 &);
# 325 "/usr/include/qt4/QtGui/qpixmap.h"



# 27 "/usr/include/qt4/QtWebKit/qwebsettings.h" 2
# 1 "/usr/include/qt4/QtGui/qicon.h" 1
# 50 "/usr/include/qt4/QtGui/qicon.h"




typedef QtValidLicenseForGuiModule QtGuiModule;

class QIconPrivate;
class QIconEngine;
class QIconEngineV2;

class QIcon
{
public:
    enum Mode { Normal, Disabled, Active, Selected };
    enum State { On, Off };

    QIcon();
    QIcon(const QPixmap &pixmap);
    QIcon(const QIcon &other);
    explicit QIcon(const QString &fileName);
    explicit QIcon(QIconEngine *engine);
    explicit QIcon(QIconEngineV2 *engine);
    ~QIcon();
    QIcon &operator=(const QIcon &other);
    operator QVariant() const;

    QPixmap pixmap(const QSize &size, Mode mode = Normal, State state = Off) const;
    inline QPixmap pixmap(int w, int h, Mode mode = Normal, State state = Off) const
        { return pixmap(QSize(w, h), mode, state); }
    inline QPixmap pixmap(int extent, Mode mode = Normal, State state = Off) const
        { return pixmap(QSize(extent, extent), mode, state); }

    QSize actualSize(const QSize &size, Mode mode = Normal, State state = Off) const;

    void paint(QPainter *painter, const QRect &rect, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off) const;
    inline void paint(QPainter *painter, int x, int y, int w, int h, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off) const
        { paint(painter, QRect(x, y, w, h), alignment, mode, state); }

    bool isNull() const;
    bool isDetached() const;
    void detach();

    int serialNumber() const;
    qint64 cacheKey() const;

    void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off);
    void addFile(const QString &fileName, const QSize &size = QSize(), Mode mode = Normal, State state = Off);

    QList<QSize> availableSizes(Mode mode = Normal, State state = Off) const;

    static QIcon fromTheme(const QString &name, const QIcon &fallback = QIcon());
    static bool hasThemeIcon(const QString &name);

    static QStringList themeSearchPaths();
    static void setThemeSearchPaths(const QStringList &searchpath);

    static QString themeName();
    static void setThemeName(const QString &path);
# 124 "/usr/include/qt4/QtGui/qicon.h"
   

private:
    QIconPrivate *d;

    friend QDataStream &operator<<(QDataStream &, const QIcon &);
    friend QDataStream &operator>>(QDataStream &, QIcon &);


public:
    typedef QIconPrivate * DataPtr;
    inline DataPtr &data_ptr() { return d; }
};

template <> inline bool qIsDetached<QIcon>(QIcon &t) { return t.isDetached(); } template <> inline void qSwap<QIcon>(QIcon &value1, QIcon &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
template <> class QTypeInfo<QIcon > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QIcon)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QIcon"; } };


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









# 28 "/usr/include/qt4/QtWebKit/qwebsettings.h" 2


namespace WebCore {
    class Settings;
}

class QWebPage;
class QWebPluginDatabase;
class QWebSettingsPrivate;

class QUrl;


class QWebSettings {
public:
    enum FontFamily {
        StandardFont,
        FixedFont,
        SerifFont,
        SansSerifFont,
        CursiveFont,
        FantasyFont
    };
    enum WebAttribute {
        AutoLoadImages,
        JavascriptEnabled,
        JavaEnabled,
        PluginsEnabled,
        PrivateBrowsingEnabled,
        JavascriptCanOpenWindows,
        JavascriptCanAccessClipboard,
        DeveloperExtrasEnabled,
        LinksIncludedInFocusChain,
        ZoomTextOnly,
        PrintElementBackgrounds,
        OfflineStorageDatabaseEnabled,
        OfflineWebApplicationCacheEnabled,
        LocalStorageEnabled,

        LocalStorageDatabaseEnabled = LocalStorageEnabled,

        LocalContentCanAccessRemoteUrls,
        DnsPrefetchEnabled
    };
    enum WebGraphic {
        MissingImageGraphic,
        MissingPluginGraphic,
        DefaultFrameIconGraphic,
        TextAreaSizeGripCornerGraphic
    };
    enum FontSize {
        MinimumFontSize,
        MinimumLogicalFontSize,
        DefaultFontSize,
        DefaultFixedFontSize
    };

    static QWebSettings *globalSettings();

    void setFontFamily(FontFamily which, const QString &family);
    QString fontFamily(FontFamily which) const;
    void resetFontFamily(FontFamily which);

    void setFontSize(FontSize type, int size);
    int fontSize(FontSize type) const;
    void resetFontSize(FontSize type);

    void setAttribute(WebAttribute attr, bool on);
    bool testAttribute(WebAttribute attr) const;
    void resetAttribute(WebAttribute attr);

    void setUserStyleSheetUrl(const QUrl &location);
    QUrl userStyleSheetUrl() const;

    void setDefaultTextEncoding(const QString &encoding);
    QString defaultTextEncoding() const;

    static void setIconDatabasePath(const QString &location);
    static QString iconDatabasePath();
    static void clearIconDatabase();
    static QIcon iconForUrl(const QUrl &url);



    static void setWebGraphic(WebGraphic type, const QPixmap &graphic);
    static QPixmap webGraphic(WebGraphic type);

    static void setMaximumPagesInCache(int pages);
    static int maximumPagesInCache();
    static void setObjectCacheCapacities(int cacheMinDeadCapacity, int cacheMaxDead, int totalCapacity);

    static void setOfflineStoragePath(const QString& path);
    static QString offlineStoragePath();
    static void setOfflineStorageDefaultQuota(qint64 maximumSize);
    static qint64 offlineStorageDefaultQuota();

    static void setOfflineWebApplicationCachePath(const QString& path);
    static QString offlineWebApplicationCachePath();
    static void setOfflineWebApplicationCacheQuota(qint64 maximumSize);
    static qint64 offlineWebApplicationCacheQuota();

    void setLocalStoragePath(const QString& path);
    QString localStoragePath() const;

    static void clearMemoryCaches();

    static void enablePersistentStorage(const QString& path = QString());

    inline QWebSettingsPrivate* handle() const { return d; }

private:
    friend class QWebPagePrivate;
    friend class QWebSettingsPrivate;

    QWebSettings(const QWebSettings &); QWebSettings &operator=(const QWebSettings &);

    QWebSettings();
    QWebSettings(WebCore::Settings *settings);
    ~QWebSettings();

    QWebSettingsPrivate *d;
};
# 25 "/usr/include/qt4/QtWebKit/qwebpage.h" 2



# 1 "/usr/include/qt4/QtCore/qurl.h" 1
# 47 "/usr/include/qt4/QtCore/qurl.h"
# 1 "/usr/include/qt4/QtCore/qpair.h" 1
# 47 "/usr/include/qt4/QtCore/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;
}





# 48 "/usr/include/qt4/QtCore/qurl.h" 2






typedef QtValidLicenseForCoreModule QtCoreModule;

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 setEncodedUserName(const QByteArray &userName);
    QByteArray encodedUserName() const;

    void setPassword(const QString &password);
    QString password() const;
    void setEncodedPassword(const QByteArray &password);
    QByteArray encodedPassword() const;

    void setHost(const QString &host);
    QString host() const;
    void setEncodedHost(const QByteArray &host);
    QByteArray encodedHost() const;

    void setPort(int port);
    int port() const;
    int port(int defaultPort) const;


    void setPath(const QString &path);
    QString path() const;
    void setEncodedPath(const QByteArray &path);
    QByteArray encodedPath() const;

    bool hasQuery() 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 setEncodedQueryItems(const QList<QPair<QByteArray, QByteArray> > &query);
    void addEncodedQueryItem(const QByteArray &key, const QByteArray &value);
    QList<QPair<QByteArray, QByteArray> > encodedQueryItems() const;
    bool hasEncodedQueryItem(const QByteArray &key) const;
    QByteArray encodedQueryItemValue(const QByteArray &key) const;
    QList<QByteArray> allEncodedQueryItemValues(const QByteArray &key) const;
    void removeEncodedQueryItem(const QByteArray &key);
    void removeAllEncodedQueryItems(const QByteArray &key);

    void setFragment(const QString &fragment);
    QString fragment() const;
    void setEncodedFragment(const QByteArray &fragment);
    QByteArray encodedFragment() const;
    bool hasFragment() 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);


    static QUrl fromUserInput(const QString &userInput);

    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 &);
    static QString fromAce(const QByteArray &);
    static QByteArray toAce(const QString &);
    static QStringList idnWhitelist();
    static void setIdnWhitelist(const QStringList &);
# 257 "/usr/include/qt4/QtCore/qurl.h"
    QString errorString() const;

public:




private:
    QUrlPrivate *d;
public:
    typedef QUrlPrivate * DataPtr;
    inline DataPtr &data_ptr() { return 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(); } template <> inline void qSwap<QUrl>(QUrl &value1, QUrl &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
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; } inline QIncompatibleFlag operator|(QUrl::FormattingOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }


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



 QDebug operator<<(QDebug, const QUrl &);





# 29 "/usr/include/qt4/QtWebKit/qwebpage.h" 2
# 1 "/usr/include/qt4/QtGui/qwidget.h" 1
# 47 "/usr/include/qt4/QtGui/qwidget.h"
# 1 "/usr/include/qt4/QtCore/qmargins.h" 1
# 47 "/usr/include/qt4/QtCore/qmargins.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

class QMargins
{
public:
    QMargins();
    QMargins(int left, int top, int right, int bottom);

    bool isNull() const;

    int left() const;
    int top() const;
    int right() const;
    int bottom() const;

    void setLeft(int left);
    void setTop(int top);
    void setRight(int right);
    void setBottom(int bottom);

private:
    int m_left;
    int m_top;
    int m_right;
    int m_bottom;

    friend inline bool operator==(const QMargins &, const QMargins &);
    friend inline bool operator!=(const QMargins &, const QMargins &);
};

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





inline QMargins::QMargins()
{ m_top = m_bottom = m_left = m_right = 0; }

inline QMargins::QMargins(int aleft, int atop, int aright, int abottom)
    : m_left(aleft), m_top(atop), m_right(aright), m_bottom(abottom) {}

inline bool QMargins::isNull() const
{ return m_left==0 && m_top==0 && m_right==0 && m_bottom==0; }

inline int QMargins::left() const
{ return m_left; }

inline int QMargins::top() const
{ return m_top; }

inline int QMargins::right() const
{ return m_right; }

inline int QMargins::bottom() const
{ return m_bottom; }


inline void QMargins::setLeft(int aleft)
{ m_left = aleft; }

inline void QMargins::setTop(int atop)
{ m_top = atop; }

inline void QMargins::setRight(int aright)
{ m_right = aright; }

inline void QMargins::setBottom(int abottom)
{ m_bottom = abottom; }

inline bool operator==(const QMargins &m1, const QMargins &m2)
{
    return
            m1.m_left == m2.m_left &&
            m1.m_top == m2.m_top &&
            m1.m_right == m2.m_right &&
            m1.m_bottom == m2.m_bottom;
}

inline bool operator!=(const QMargins &m1, const QMargins &m2)
{
    return
            m1.m_left != m2.m_left ||
            m1.m_top != m2.m_top ||
            m1.m_right != m2.m_right ||
            m1.m_bottom != m2.m_bottom;
}


 QDebug operator<<(QDebug, const QMargins &);





# 48 "/usr/include/qt4/QtGui/qwidget.h" 2

# 1 "/usr/include/qt4/QtGui/qpalette.h" 1
# 47 "/usr/include/qt4/QtGui/qpalette.h"
# 1 "/usr/include/qt4/QtGui/qbrush.h" 1
# 64 "/usr/include/qt4/QtGui/qbrush.h"




typedef QtValidLicenseForGuiModule QtGuiModule;

struct QBrushData;
class QPixmap;
class QGradient;
class QVariant;
struct QBrushDataPointerDeleter;

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 QImage &image);

    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);

    inline const QMatrix &matrix() const;
    void setMatrix(const QMatrix &mat);

    inline QTransform transform() const;
    void setTransform(const QTransform &);

    QPixmap texture() const;
    void setTexture(const QPixmap &pixmap);

    QImage textureImage() const;
    void setTextureImage(const QImage &image);

    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)); }







private:

    friend class QX11PaintEngine;

    friend class QRasterPaintEngine;
    friend class QRasterPaintEnginePrivate;
    friend struct QSpanData;
    friend class QPainter;
    friend bool qHasPixmapTexture(const QBrush& brush);
    void detach(Qt::BrushStyle newStyle);
    void init(const QColor &color, Qt::BrushStyle bs);
    QScopedPointer<QBrushData, QBrushDataPointerDeleter> d;
    void cleanUp(QBrushData *x);

public:
    inline bool isDetached() const;
    typedef QScopedPointer<QBrushData, QBrushDataPointerDeleter> DataPtr;
    inline DataPtr &data_ptr() { return d; }
};

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"; } };
template <> inline bool qIsDetached<QBrush>(QBrush &t) { return t.isDetached(); } template <> inline void qSwap<QBrush>(QBrush &value1, QBrush &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }






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



 QDebug operator<<(QDebug, const QBrush &);


struct QBrushData
{
    QAtomicInt ref;
    Qt::BrushStyle style;
    QColor color;
    QTransform transform;
};

inline Qt::BrushStyle QBrush::style() const { return d->style; }
inline const QColor &QBrush::color() const { return d->color; }
inline const QMatrix &QBrush::matrix() const { return d->transform.toAffine(); }
inline QTransform QBrush::transform() const { return d->transform; }
inline bool QBrush::isDetached() const { return d->ref == 1; }
# 190 "/usr/include/qt4/QtGui/qbrush.h"
class QGradientPrivate;

typedef QPair<qreal, QColor> QGradientStop;
typedef QVector<QGradientStop> QGradientStops;

class QGradient
{
    public: static const QMetaObject staticMetaObject; private:
   
public:
    enum Type {
        LinearGradient,
        RadialGradient,
        ConicalGradient,
        NoGradient
    };

    enum Spread {
        PadSpread,
        ReflectSpread,
        RepeatSpread
    };

    enum CoordinateMode {
        LogicalMode,
        StretchToDeviceMode,
        ObjectBoundingMode
    };

    enum InterpolationMode {
        ColorInterpolation,
        ComponentInterpolation
    };

    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;

    CoordinateMode coordinateMode() const;
    void setCoordinateMode(CoordinateMode mode);

    InterpolationMode interpolationMode() const;
    void setInterpolationMode(InterpolationMode mode);

    bool operator==(const QGradient &gradient) const;
    inline bool operator!=(const QGradient &other) const
    { return !operator==(other); }

    bool operator==(const QGradient &gradient);

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();
    QLinearGradient(const QPointF &start, const QPointF &finalStop);
    QLinearGradient(qreal xStart, qreal yStart, qreal xFinalStop, qreal yFinalStop);

    QPointF start() const;
    void setStart(const QPointF &start);
    inline void setStart(qreal x, qreal y) { setStart(QPointF(x, y)); }

    QPointF finalStop() const;
    void setFinalStop(const QPointF &stop);
    inline void setFinalStop(qreal x, qreal y) { setFinalStop(QPointF(x, y)); }
};


class QRadialGradient : public QGradient
{
public:
    QRadialGradient();
    QRadialGradient(const QPointF &center, qreal radius, const QPointF &focalPoint);
    QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qreal fy);

    QRadialGradient(const QPointF &center, qreal radius);
    QRadialGradient(qreal cx, qreal cy, qreal radius);

    QPointF center() const;
    void setCenter(const QPointF &center);
    inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); }

    QPointF focalPoint() const;
    void setFocalPoint(const QPointF &focalPoint);
    inline void setFocalPoint(qreal x, qreal y) { setFocalPoint(QPointF(x, y)); }

    qreal radius() const;
    void setRadius(qreal radius);
};


class QConicalGradient : public QGradient
{
public:
    QConicalGradient();
    QConicalGradient(const QPointF &center, qreal startAngle);
    QConicalGradient(qreal cx, qreal cy, qreal startAngle);

    QPointF center() const;
    void setCenter(const QPointF &center);
    inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); }

    qreal angle() const;
    void setAngle(qreal angle);
};




# 48 "/usr/include/qt4/QtGui/qpalette.h" 2





typedef QtValidLicenseForGuiModule QtGuiModule;




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);



    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,
                     NoRole,
                     ToolTipBase, ToolTipText,
                     NColorRoles = ToolTipText + 1,
                     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);
    bool isBrushSet(ColorGroup cg, ColorRole cr) const;
    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(WindowText); }
    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 &toolTipBase() const { return brush(ToolTipBase); }
    inline const QBrush &toolTipText() const { return brush(ToolTipText); }
    inline const QBrush &background() const { return brush(Window); }
    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); }
# 150 "/usr/include/qt4/QtGui/qpalette.h"
    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;
    qint64 cacheKey() 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);
    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,
                       const QBrush &toolTipBase, const QBrush &toolTipText);





    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); }
# 254 "/usr/include/qt4/QtGui/qpalette.h"
 QDataStream &operator<<(QDataStream &ds, const QPalette &p);
 QDataStream &operator>>(QDataStream &ds, QPalette &p);





# 50 "/usr/include/qt4/QtGui/qwidget.h" 2
# 1 "/usr/include/qt4/QtGui/qfont.h" 1
# 50 "/usr/include/qt4/QtGui/qfont.h"
typedef struct FT_FaceRec_* FT_Face;






typedef QtValidLicenseForGuiModule QtGuiModule;

class QFontPrivate;
class QStringList;
class QVariant;
class Q3TextFormatCollection;

class QFont
{
    public: static const QMetaObject staticMetaObject; private:
   
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,
        NoFontMerging = 0x8000
    };

    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
    };

    enum Capitalization {
        MixedCase,
        AllUppercase,
        AllLowercase,
        SmallCaps,
        Capitalize
    };

    enum SpacingType {
        PercentageSpacing,
        AbsoluteSpacing
    };

    enum ResolveProperties {
        FamilyResolved = 0x0001,
        SizeResolved = 0x0002,
        StyleHintResolved = 0x0004,
        StyleStrategyResolved = 0x0008,
        WeightResolved = 0x0010,
        StyleResolved = 0x0020,
        UnderlineResolved = 0x0040,
        OverlineResolved = 0x0080,
        StrikeOutResolved = 0x0100,
        FixedPitchResolved = 0x0200,
        StretchResolved = 0x0400,
        KerningResolved = 0x0800,
        CapitalizationResolved = 0x1000,
        LetterSpacingResolved = 0x2000,
        WordSpacingResolved = 0x4000,
        AllPropertiesResolved = 0x7fff
    };

    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);

    qreal letterSpacing() const;
    SpacingType letterSpacingType() const;
    void setLetterSpacing(SpacingType type, qreal spacing);

    qreal wordSpacing() const;
    void setWordSpacing(qreal spacing);

    void setCapitalization(Capitalization);
    Capitalization capitalization() const;


    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;





    FT_Face freetypeFace() 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; }
# 276 "/usr/include/qt4/QtGui/qfont.h"
private:
    QFont(QFontPrivate *);

    void detach();




    void x11SetScreen(int screen = -1);
    int x11Screen() const;


    friend class QFontPrivate;
    friend class QFontDialogPrivate;
    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 QStackTextEngine;
    friend class QTextLine;
    friend struct QScriptLine;
    friend class QGLContext;
    friend class QWin32PaintEngine;
    friend class QAlphaPaintEngine;
    friend class QPainterPath;
    friend class QTextItemInt;
    friend class QPicturePaintEngine;
    friend class QPainterReplayer;
    friend class QPaintBufferEngine;
    friend class QCommandLinkButtonPrivate;


    friend QDataStream &operator<<(QDataStream &, const QFont &);
    friend QDataStream &operator>>(QDataStream &, QFont &);


    QExplicitlySharedDataPointer<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 &);



 QDebug operator<<(QDebug, const QFont &);





# 51 "/usr/include/qt4/QtGui/qwidget.h" 2
# 1 "/usr/include/qt4/QtGui/qfontmetrics.h" 1
# 51 "/usr/include/qt4/QtGui/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;
    int averageCharWidth() 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;

    QRect tightBoundingRect(const QString &text) const;

    QString elidedText(const QString &text, Qt::TextElideMode mode, int width, int flags = 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 bool operator !=(const QFontMetrics &other) const { return !operator==(other); }
# 128 "/usr/include/qt4/QtGui/qfontmetrics.h"
private:



    friend class QFontMetricsF;
    friend class QStackTextEngine;

    QExplicitlySharedDataPointer<QFontPrivate> d;
};


class QFontMetricsF
{
public:
    QFontMetricsF(const QFont &);
    QFontMetricsF(const QFont &, QPaintDevice *pd);
    QFontMetricsF(const QFontMetrics &);
    QFontMetricsF(const QFontMetricsF &);
    ~QFontMetricsF();

    QFontMetricsF &operator=(const QFontMetricsF &);
    QFontMetricsF &operator=(const QFontMetrics &);

    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;
    qreal averageCharWidth() 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;

    QRectF tightBoundingRect(const QString &text) const;

    QString elidedText(const QString &text, Qt::TextElideMode mode, qreal width, int flags = 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:
    QExplicitlySharedDataPointer<QFontPrivate> d;
};




# 52 "/usr/include/qt4/QtGui/qwidget.h" 2
# 1 "/usr/include/qt4/QtGui/qfontinfo.h" 1
# 48 "/usr/include/qt4/QtGui/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:
    QExplicitlySharedDataPointer<QFontPrivate> d;
};




# 53 "/usr/include/qt4/QtGui/qwidget.h" 2
# 1 "/usr/include/qt4/QtGui/qsizepolicy.h" 1
# 47 "/usr/include/qt4/QtGui/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,
  CTShift = 9,
  CTSize = 5,
                WFHShift = CTShift + CTSize,
  CTMask = ((0x1 << CTSize) - 1) << CTShift,
  UnusedShift = CTShift + CTSize,
  UnusedSize = 2
    };

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
    };

    enum ControlType {
        DefaultType = 0x00000001,
        ButtonBox = 0x00000002,
        CheckBox = 0x00000004,
        ComboBox = 0x00000008,
        Frame = 0x00000010,
        GroupBox = 0x00000020,
        Label = 0x00000040,
        Line = 0x00000080,
        LineEdit = 0x00000100,
        PushButton = 0x00000200,
        RadioButton = 0x00000400,
        Slider = 0x00000800,
        SpinBox = 0x00001000,
        TabWidget = 0x00002000,
        ToolButton = 0x00004000
    };
    typedef QFlags<ControlType> ControlTypes;

    QSizePolicy() : data(0) { }


    QSizePolicy(Policy horizontal, Policy vertical)
        : data(horizontal | (vertical << HSize)) { }
    QSizePolicy(Policy horizontal, Policy vertical, ControlType type)
        : data(horizontal | (vertical << HSize)) { setControlType(type); }

    Policy horizontalPolicy() const { return static_cast<Policy>(data & HMask); }
    Policy verticalPolicy() const { return static_cast<Policy>((data & VMask) >> HSize); }
    ControlType controlType() const;

    void setHorizontalPolicy(Policy d) { data = (data & ~HMask) | d; }
    void setVerticalPolicy(Policy d) { data = (data & ~(HMask << HSize)) | (d << HSize); }
    void setControlType(ControlType type);

    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();
# 195 "/usr/include/qt4/QtGui/qsizepolicy.h"
private:

    friend QDataStream &operator<<(QDataStream &, const QSizePolicy &);
    friend QDataStream &operator>>(QDataStream &, QSizePolicy &);

    QSizePolicy(int i) : data(i) { }

    quint32 data;
# 214 "/usr/include/qt4/QtGui/qsizepolicy.h"
};

inline QFlags<QSizePolicy::ControlTypes::enum_type> operator|(QSizePolicy::ControlTypes::enum_type f1, QSizePolicy::ControlTypes::enum_type f2) { return QFlags<QSizePolicy::ControlTypes::enum_type>(f1) | f2; } inline QFlags<QSizePolicy::ControlTypes::enum_type> operator|(QSizePolicy::ControlTypes::enum_type f1, QFlags<QSizePolicy::ControlTypes::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QSizePolicy::ControlTypes::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }



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


inline void QSizePolicy::transpose() {
    Policy hData = horizontalPolicy();
    Policy vData = verticalPolicy();
    uchar hStretch = uchar(horizontalStretch());
    uchar vStretch = uchar(verticalStretch());
    setHorizontalPolicy(vData);
    setVerticalPolicy(hData);
    setHorizontalStretch(vStretch);
    setVerticalStretch(hStretch);
}




# 54 "/usr/include/qt4/QtGui/qwidget.h" 2


# 1 "/usr/include/qt4/QtGui/qcursor.h" 1
# 48 "/usr/include/qt4/QtGui/qcursor.h"




typedef QtValidLicenseForGuiModule QtGuiModule;

class QVariant;
# 75 "/usr/include/qt4/QtGui/qcursor.h"
class QCursorData;
class QBitmap;
class QPixmap;
# 89 "/usr/include/qt4/QtGui/qcursor.h"
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()); }
# 124 "/usr/include/qt4/QtGui/qcursor.h"
    Qt::HANDLE handle() const;
    QCursor(Qt::HANDLE cursor);
    static int x11Screen();
# 136 "/usr/include/qt4/QtGui/qcursor.h"
private:
    QCursorData *d;
# 148 "/usr/include/qt4/QtGui/qcursor.h"
};
# 166 "/usr/include/qt4/QtGui/qcursor.h"
 QDataStream &operator<<(QDataStream &outS, const QCursor &cursor);
 QDataStream &operator>>(QDataStream &inS, QCursor &cursor);






# 57 "/usr/include/qt4/QtGui/qwidget.h" 2
# 1 "/usr/include/qt4/QtGui/qkeysequence.h" 1
# 48 "/usr/include/qt4/QtGui/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:
    enum StandardKey {
        UnknownKey,
        HelpContents,
        WhatsThis,
        Open,
        Close,
        Save,
        New,
        Delete,
        Cut,
        Copy,
        Paste,
        Undo,
        Redo,
        Back,
        Forward,
        Refresh,
        ZoomIn,
        ZoomOut,
        Print,
        AddTab,
        NextChild,
        PreviousChild,
        Find,
        FindNext,
        FindPrevious,
        Replace,
        SelectAll,
        Bold,
        Italic,
        Underline,
        MoveToNextChar,
        MoveToPreviousChar,
        MoveToNextWord,
        MoveToPreviousWord,
        MoveToNextLine,
        MoveToPreviousLine,
        MoveToNextPage,
        MoveToPreviousPage,
        MoveToStartOfLine,
        MoveToEndOfLine,
        MoveToStartOfBlock,
        MoveToEndOfBlock,
        MoveToStartOfDocument,
        MoveToEndOfDocument,
        SelectNextChar,
        SelectPreviousChar,
        SelectNextWord,
        SelectPreviousWord,
        SelectNextLine,
        SelectPreviousLine,
        SelectNextPage,
        SelectPreviousPage,
        SelectStartOfLine,
        SelectEndOfLine,
        SelectStartOfBlock,
        SelectEndOfBlock,
        SelectStartOfDocument,
        SelectEndOfDocument,
        DeleteStartOfWord,
        DeleteEndOfWord,
        DeleteEndOfLine,
        InsertParagraphSeparator,
        InsertLineSeparator,
        SaveAs,
        Preferences,
        Quit
     };

    QKeySequence();
    QKeySequence(const QString &key);
    QKeySequence(int k1, int k2 = 0, int k3 = 0, int k4 = 0);
    QKeySequence(const QKeySequence &ks);
    QKeySequence(StandardKey key);
    ~QKeySequence();

    uint count() const;
    bool isEmpty() const;

    enum SequenceMatch {
        NoMatch,
        PartialMatch,
        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);
    static QList<QKeySequence> keyBindings(StandardKey key);


    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;

public:
    typedef QKeySequencePrivate * DataPtr;
    inline DataPtr &data_ptr() { return d; }
};
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(); } template <> inline void qSwap<QKeySequence>(QKeySequence &value1, QKeySequence &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }


 QDebug operator<<(QDebug, const QKeySequence &);
# 229 "/usr/include/qt4/QtGui/qkeysequence.h"



# 58 "/usr/include/qt4/QtGui/qwidget.h" 2









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 QWindowSurface;
class QLocale;
class QGraphicsProxyWidget;
class QGraphicsEffect;

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 in_destructor : 1;
    uint unused : 13;
    QRect crect;
    mutable QPalette pal;
    QFont fnt;
# 135 "/usr/include/qt4/QtGui/qwidget.h"
    QRect wrect;
};

class QWidgetPrivate;

class QWidget : public QObject, public QPaintDevice
{
    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } 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); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private:
    inline QWidgetPrivate* d_func() { return reinterpret_cast<QWidgetPrivate *>(qGetPtrHelper(d_ptr)); } inline const QWidgetPrivate* d_func() const { return reinterpret_cast<const QWidgetPrivate *>(qGetPtrHelper(d_ptr)); } friend class QWidgetPrivate;

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   

   

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   

   


   


   





   
   
   

   

   
   
   

public:
    enum RenderFlag {
        DrawWindowBackground = 0x1,
        DrawChildren = 0x2,
        IgnoreMask = 0x4
    };
    typedef QFlags<RenderFlag> RenderFlags;

    explicit QWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);



    ~QWidget();

    int devType() const;

    WId winId() const;
    void createWinId();
    inline WId internalWinId() const { return data->winid; }
    WId effectiveWinId() 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;
    QWidget *nativeParentWidget() 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 render(QPaintDevice *target, const QPoint &targetOffset = QPoint(),
                const QRegion &sourceRegion = QRegion(),
                RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren));

    void render(QPainter *painter, const QPoint &targetOffset = QPoint(),
                const QRegion &sourceRegion = QRegion(),
                RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren));


    QGraphicsEffect *graphicsEffect() const;
    void setGraphicsEffect(QGraphicsEffect *effect);


    void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags());
    void ungrabGesture(Qt::GestureType type);

public :
    void setWindowTitle(const QString &);

    void setStyleSheet(const QString& styleSheet);

public:

    QString styleSheet() const;

    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 setWindowFilePath(const QString &filePath);
    QString windowFilePath() 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;
# 408 "/usr/include/qt4/QtGui/qwidget.h"
    void setLayoutDirection(Qt::LayoutDirection direction);
    Qt::LayoutDirection layoutDirection() const;
    void unsetLayoutDirection();

    void setLocale(const QLocale &locale);
    QLocale locale() const;
    void unsetLocale();

    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);
    void setShortcutAutoRepeat(int id, bool enable = true);

    static QWidget *mouseGrabber();
    static QWidget *keyboardGrabber();


    inline bool updatesEnabled() const;
    void setUpdatesEnabled(bool enable);






    QGraphicsProxyWidget *graphicsProxyWidget() const;


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 &);
    QByteArray saveGeometry() const;
    bool restoreGeometry(const QByteArray &geometry);
    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 setContentsMargins(const QMargins &margins);
    void getContentsMargins(int *left, int *top, int *right, int *bottom) const;
    QMargins contentsMargins() const;

    QRect contentsRect() const;

public:
    QLayout *layout() const;
    void setLayout(QLayout *);
    void updateGeometry();

    void setParent(QWidget *parent);
    void setParent(QWidget *parent, Qt::WindowFlags f);

    void scroll(int dx, int dy);
    void scroll(int dx, int dy, const QRect&);



    QWidget *focusWidget() const;
    QWidget *nextInFocusChain() const;
    QWidget *previousInFocusChain() 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);



    inline QWidget *childAt(int x, int y) const;
    QWidget *childAt(const QPoint &p) const;


    const QX11Info &x11Info() const;
    Qt::HANDLE x11PictureHandle() const;
# 602 "/usr/include/qt4/QtGui/qwidget.h"
    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);

    void setWindowSurface(QWindowSurface *surface);
    QWindowSurface *windowSurface() const;

public:
    void customContextMenuRequested(const QPoint &pos);

public:

    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 *);
# 678 "/usr/include/qt4/QtGui/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;

    Qt::InputMethodHints inputMethodHints() const;
    void setInputMethodHints(Qt::InputMethodHints hints);

public:
    void resetInputContext();
public :
    void updateMicroFocus();
public:

    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); }

public:
    QWidget(QWidgetPrivate &d, QWidget* parent, Qt::WindowFlags f);
private:

    bool testAttribute_helper(Qt::WidgetAttribute) const;

    QLayout *takeLayout();

    friend class QBackingStoreDevice;
    friend class QWidgetBackingStore;
    friend class QApplication;
    friend class QApplicationPrivate;
    friend class QBaseApplication;
    friend class QPainter;
    friend class QPainterPrivate;
    friend class QPixmap;
    friend class QFontMetrics;
    friend class QFontInfo;
    friend class QETWidget;
    friend class QLayout;
    friend class QWidgetItem;
    friend class QWidgetItemV2;
    friend class QGLContext;
    friend class QGLWidget;
    friend class QGLWindowSurface;
    friend class QX11PaintEngine;
    friend class QWin32PaintEngine;
    friend class QShortcutPrivate;
    friend class QShortcutMap;
    friend class QWindowSurface;
    friend class QGraphicsProxyWidget;
    friend class QGraphicsProxyWidgetPrivate;
    friend class QStyleSheetStyle;
    friend struct QWidgetExceptionCleaner;
    friend class QGestureManager;
    friend class QWinNativePanGestureRecognizer;
    friend class QWidgetEffectSourcePrivate;
# 774 "/usr/include/qt4/QtGui/qwidget.h"
    friend void qt_net_update_user_time(QWidget *tlw, unsigned long timestamp);
    friend void qt_net_remove_user_time(QWidget *tlw);


    friend QWidgetData *qt_qwidget_data(QWidget *widget);
    friend QWidgetPrivate *qt_widget_private(QWidget *widget);

private:
    QWidget(const QWidget &); QWidget &operator=(const QWidget &);
   




    QWidgetData *data;
# 885 "/usr/include/qt4/QtGui/qwidget.h"
public:
    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();
};

inline QFlags<QWidget::RenderFlags::enum_type> operator|(QWidget::RenderFlags::enum_type f1, QWidget::RenderFlags::enum_type f2) { return QFlags<QWidget::RenderFlags::enum_type>(f1) | f2; } inline QFlags<QWidget::RenderFlags::enum_type> operator|(QWidget::RenderFlags::enum_type f1, QFlags<QWidget::RenderFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QWidget::RenderFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
# 903 "/usr/include/qt4/QtGui/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 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);
}
# 1070 "/usr/include/qt4/QtGui/qwidget.h"



# 30 "/usr/include/qt4/QtWebKit/qwebpage.h" 2


class QNetworkProxy;
class QUndoStack;
class QMenu;
class QNetworkRequest;
class QNetworkReply;
class QNetworkAccessManager;


class QWebElement;
class QWebFrame;
class QWebNetworkRequest;
class QWebHistory;

class QWebPagePrivate;
class QWebFrameData;
class QWebNetworkInterface;
class QWebPluginFactory;
class QWebHitTestResult;
class QWebHistoryItem;

namespace WebCore {
    class ChromeClientQt;
    class EditorClientQt;
    class FrameLoaderClientQt;
    class InspectorClientQt;
    class ResourceHandle;
    class HitTestResult;
    class QNetworkReplyHandler;

    struct FrameLoadRequest;
}

class QWebPage : public QObject {
    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } 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); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private:

   
   
   
   
   
   
   
   
   
public:
    enum NavigationType {
        NavigationTypeLinkClicked,
        NavigationTypeFormSubmitted,
        NavigationTypeBackOrForward,
        NavigationTypeReload,
        NavigationTypeFormResubmitted,
        NavigationTypeOther
    };

    enum WebAction {
        NoWebAction = - 1,

        OpenLink,

        OpenLinkInNewWindow,
        OpenFrameInNewWindow,

        DownloadLinkToDisk,
        CopyLinkToClipboard,

        OpenImageInNewWindow,
        DownloadImageToDisk,
        CopyImageToClipboard,

        Back,
        Forward,
        Stop,
        Reload,

        Cut,
        Copy,
        Paste,

        Undo,
        Redo,
        MoveToNextChar,
        MoveToPreviousChar,
        MoveToNextWord,
        MoveToPreviousWord,
        MoveToNextLine,
        MoveToPreviousLine,
        MoveToStartOfLine,
        MoveToEndOfLine,
        MoveToStartOfBlock,
        MoveToEndOfBlock,
        MoveToStartOfDocument,
        MoveToEndOfDocument,
        SelectNextChar,
        SelectPreviousChar,
        SelectNextWord,
        SelectPreviousWord,
        SelectNextLine,
        SelectPreviousLine,
        SelectStartOfLine,
        SelectEndOfLine,
        SelectStartOfBlock,
        SelectEndOfBlock,
        SelectStartOfDocument,
        SelectEndOfDocument,
        DeleteStartOfWord,
        DeleteEndOfWord,

        SetTextDirectionDefault,
        SetTextDirectionLeftToRight,
        SetTextDirectionRightToLeft,

        ToggleBold,
        ToggleItalic,
        ToggleUnderline,

        InspectElement,

        InsertParagraphSeparator,
        InsertLineSeparator,

        SelectAll,
        ReloadAndBypassCache,

        PasteAndMatchStyle,
        RemoveFormat,

        ToggleStrikethrough,
        ToggleSubscript,
        ToggleSuperscript,
        InsertUnorderedList,
        InsertOrderedList,
        Indent,
        Outdent,

        AlignCenter,
        AlignJustified,
        AlignLeft,
        AlignRight,

        WebActionCount
    };

    enum FindFlag {
        FindBackward = 1,
        FindCaseSensitively = 2,
        FindWrapsAroundDocument = 4,
        HighlightAllOccurrences = 8
    };
    typedef QFlags<FindFlag> FindFlags;

    enum LinkDelegationPolicy {
        DontDelegateLinks,
        DelegateExternalLinks,
        DelegateAllLinks
    };

    enum WebWindowType {
        WebBrowserWindow,
        WebModalDialog
    };

    explicit QWebPage(QObject *parent = 0);
    ~QWebPage();

    QWebFrame *mainFrame() const;
    QWebFrame *currentFrame() const;
    QWebFrame* frameAt(const QPoint& pos) const;

    QWebHistory *history() const;
    QWebSettings *settings() const;

    void setView(QWidget *view);
    QWidget *view() const;

    bool isModified() const;

    QUndoStack *undoStack() const;
# 222 "/usr/include/qt4/QtWebKit/qwebpage.h"
    void setNetworkAccessManager(QNetworkAccessManager *manager);
    QNetworkAccessManager *networkAccessManager() const;


    void setPluginFactory(QWebPluginFactory *factory);
    QWebPluginFactory *pluginFactory() const;

    quint64 totalBytes() const;
    quint64 bytesReceived() const;

    QString selectedText() const;

    QAction *action(WebAction action) const;
    virtual void triggerAction(WebAction action, bool checked = false);

    QSize viewportSize() const;
    void setViewportSize(const QSize &size) const;

    QSize preferredContentsSize() const;
    void setPreferredContentsSize(const QSize &size) const;

    virtual bool event(QEvent*);
    bool focusNextPrevChild(bool next);

    QVariant inputMethodQuery(Qt::InputMethodQuery property) const;

    bool findText(const QString &subString, FindFlags options = 0);

    void setForwardUnsupportedContent(bool forward);
    bool forwardUnsupportedContent() const;

    void setLinkDelegationPolicy(LinkDelegationPolicy policy);
    LinkDelegationPolicy linkDelegationPolicy() const;

    void setPalette(const QPalette &palette);
    QPalette palette() const;

    void setContentEditable(bool editable);
    bool isContentEditable() const;


    bool swallowContextMenuEvent(QContextMenuEvent *event);

    void updatePositionDependentActions(const QPoint &pos);

    QMenu *createStandardContextMenu();

    enum Extension {
        ChooseMultipleFilesExtension,
        ErrorPageExtension
    };
    class ExtensionOption
    {};
    class ExtensionReturn
    {};

    class ChooseMultipleFilesExtensionOption : public ExtensionOption {
    public:
        QWebFrame *parentFrame;
        QStringList suggestedFileNames;
    };

    class ChooseMultipleFilesExtensionReturn : public ExtensionReturn {
    public:
        QStringList fileNames;
    };

    enum ErrorDomain { QtNetwork, Http, WebKit };
    class ErrorPageExtensionOption : public ExtensionOption {
    public:
        QUrl url;
        QWebFrame* frame;
        ErrorDomain domain;
        int error;
        QString errorString;
    };

    class ErrorPageExtensionReturn : public ExtensionReturn {
    public:
        ErrorPageExtensionReturn() : contentType(QLatin1String("text/html")), encoding(QLatin1String("utf-8")) {};
        QString contentType;
        QString encoding;
        QUrl baseUrl;
        QByteArray content;
    };


    virtual bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
    virtual bool supportsExtension(Extension extension) const;

    inline QWebPagePrivate* handle() const { return d; }

public :
    bool shouldInterruptJavaScript();

public:
    void loadStarted();
    void loadProgress(int progress);
    void loadFinished(bool ok);

    void linkHovered(const QString &link, const QString &title, const QString &textContent);
    void statusBarMessage(const QString& text);
    void selectionChanged();
    void frameCreated(QWebFrame *frame);
    void geometryChangeRequested(const QRect& geom);
    void repaintRequested(const QRect& dirtyRect);
    void scrollRequested(int dx, int dy, const QRect& scrollViewRect);
    void windowCloseRequested();
    void printRequested(QWebFrame *frame);
    void linkClicked(const QUrl &url);

    void toolBarVisibilityChangeRequested(bool visible);
    void statusBarVisibilityChangeRequested(bool visible);
    void menuBarVisibilityChangeRequested(bool visible);


    void unsupportedContent(QNetworkReply *reply);
    void downloadRequested(const QNetworkRequest &request);


    void microFocusChanged();
    void contentsChanged();
    void databaseQuotaExceeded(QWebFrame* frame, QString databaseName);

    void saveFrameStateRequested(QWebFrame* frame, QWebHistoryItem* item);
    void restoreFrameStateRequested(QWebFrame* frame);

public:
    virtual QWebPage *createWindow(WebWindowType type);
    virtual QObject *createPlugin(const QString &classid, const QUrl &url, const QStringList &paramNames, const QStringList &paramValues);


    virtual bool acceptNavigationRequest(QWebFrame *frame, const QNetworkRequest &request, NavigationType type);



    virtual QString chooseFile(QWebFrame *originatingFrame, const QString& oldFile);
    virtual void javaScriptAlert(QWebFrame *originatingFrame, const QString& msg);
    virtual bool javaScriptConfirm(QWebFrame *originatingFrame, const QString& msg);
    virtual bool javaScriptPrompt(QWebFrame *originatingFrame, const QString& msg, const QString& defaultValue, QString* result);
    virtual void javaScriptConsoleMessage(const QString& message, int lineNumber, const QString& sourceID);

    virtual QString userAgentForUrl(const QUrl& url) const;

private:
   
   
   

    QWebPagePrivate *d;

    friend class QWebFrame;
    friend class QWebPagePrivate;
    friend class QWebView;
    friend class QGraphicsWebView;
    friend class QWebInspector;
    friend class WebCore::ChromeClientQt;
    friend class WebCore::EditorClientQt;
    friend class WebCore::FrameLoaderClientQt;
    friend class WebCore::InspectorClientQt;
    friend class WebCore::ResourceHandle;
    friend class WebCore::QNetworkReplyHandler;
};

inline QFlags<QWebPage::FindFlags::enum_type> operator|(QWebPage::FindFlags::enum_type f1, QWebPage::FindFlags::enum_type f2) { return QFlags<QWebPage::FindFlags::enum_type>(f1) | f2; } inline QFlags<QWebPage::FindFlags::enum_type> operator|(QWebPage::FindFlags::enum_type f1, QFlags<QWebPage::FindFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QWebPage::FindFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp" 2





# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 1
# 26 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp"
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
# 27 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 1
# 27 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp"
# 1 "/usr/include/boost-1_42/boost/python.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python.hpp"
# 1 "/usr/include/boost-1_42/boost/python/args.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/detail/prefix.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/detail/prefix.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp" 1
# 50 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp"
# 1 "/usr/include/python2.6/pyconfig.h" 1
# 51 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp" 2
# 61 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 3 4
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
# 169 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 145 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 157 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 39 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 40 "/usr/include/bits/local_lim.h" 2 3 4
# 158 "/usr/include/bits/posix1_lim.h" 2 3 4
# 146 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 150 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 34 "/usr/include/bits/xopen_lim.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 35 "/usr/include/bits/xopen_lim.h" 2 3 4
# 154 "/usr/include/limits.h" 2 3 4
# 170 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 2 3 4
# 8 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/syslimits.h" 2 3 4
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 2 3 4
# 62 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp" 2
# 75 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp"
# 1 "/usr/include/python2.6/patchlevel.h" 1
# 76 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp" 2
# 142 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp"
# 1 "/usr/include/python2.6/Python.h" 1






# 1 "/usr/include/python2.6/patchlevel.h" 1
# 8 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/pyconfig.h" 1
# 9 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/pymacconfig.h" 1
# 10 "/usr/include/python2.6/Python.h" 2
# 19 "/usr/include/python2.6/Python.h"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
# 20 "/usr/include/python2.6/Python.h" 2
# 33 "/usr/include/python2.6/Python.h"
# 1 "/usr/include/stdio.h" 1 3 4
# 30 "/usr/include/stdio.h" 3 4
extern "C" {



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 35 "/usr/include/stdio.h" 2 3 4
# 75 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 32 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 15 "/usr/include/_G_config.h" 3 4
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 16 "/usr/include/_G_config.h" 2 3 4




# 1 "/usr/include/wchar.h" 1 3 4
# 21 "/usr/include/_G_config.h" 2 3 4

typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
# 53 "/usr/include/_G_config.h" 3 4
typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 33 "/usr/include/libio.h" 2 3 4
# 170 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 180 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 203 "/usr/include/libio.h" 3 4
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 271 "/usr/include/libio.h" 3 4
struct _IO_FILE {
  int _flags;




  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;



  int _flags2;

  __off_t _old_offset;



  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 319 "/usr/include/libio.h" 3 4
  __off64_t _offset;
# 328 "/usr/include/libio.h" 3 4
  void *__pad1;
  void *__pad2;
  void *__pad3;
  void *__pad4;
  size_t __pad5;

  int _mode;

  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];

};





struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 364 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
     size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);


typedef int __io_close_fn (void *__cookie);




typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;


typedef struct
{
  __io_read_fn *read;
  __io_write_fn *write;
  __io_seek_fn *seek;
  __io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;

struct _IO_cookie_file;


extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
        void *__cookie, _IO_cookie_io_functions_t __fns);




extern "C" {


extern int __underflow (_IO_FILE *);
extern int __uflow (_IO_FILE *);
extern int __overflow (_IO_FILE *, int);
# 460 "/usr/include/libio.h" 3 4
extern int _IO_getc (_IO_FILE *__fp);
extern int _IO_putc (int __c, _IO_FILE *__fp);
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();

extern int _IO_peekc_locked (_IO_FILE *__fp);





extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
# 490 "/usr/include/libio.h" 3 4
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
   __gnuc_va_list, int *__restrict);
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
    __gnuc_va_list);
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);

extern void _IO_free_backup_area (_IO_FILE *) throw ();
# 552 "/usr/include/libio.h" 3 4
}
# 76 "/usr/include/stdio.h" 2 3 4
# 89 "/usr/include/stdio.h" 3 4


typedef _G_fpos_t fpos_t;





typedef _G_fpos64_t fpos64_t;
# 141 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 142 "/usr/include/stdio.h" 2 3 4



extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;







extern int remove (__const char *__filename) throw ();

extern int rename (__const char *__old, __const char *__new) throw ();




extern int renameat (int __oldfd, __const char *__old, int __newfd,
       __const char *__new) throw ();








extern FILE *tmpfile (void) __attribute__ ((__warn_unused_result__));
# 182 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void) __attribute__ ((__warn_unused_result__));



extern char *tmpnam (char *__s) throw () __attribute__ ((__warn_unused_result__));





extern char *tmpnam_r (char *__s) throw () __attribute__ ((__warn_unused_result__));
# 204 "/usr/include/stdio.h" 3 4
extern char *tempnam (__const char *__dir, __const char *__pfx)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

# 229 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 239 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);









extern FILE *fopen (__const char *__restrict __filename,
      __const char *__restrict __modes) __attribute__ ((__warn_unused_result__));




extern FILE *freopen (__const char *__restrict __filename,
        __const char *__restrict __modes,
        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
# 272 "/usr/include/stdio.h" 3 4


extern FILE *fopen64 (__const char *__restrict __filename,
        __const char *__restrict __modes) __attribute__ ((__warn_unused_result__));
extern FILE *freopen64 (__const char *__restrict __filename,
   __const char *__restrict __modes,
   FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));




extern FILE *fdopen (int __fd, __const char *__modes) throw () __attribute__ ((__warn_unused_result__));





extern FILE *fopencookie (void *__restrict __magic_cookie,
     __const char *__restrict __modes,
     _IO_cookie_io_functions_t __io_funcs) throw () __attribute__ ((__warn_unused_result__));




extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes)
  throw () __attribute__ ((__warn_unused_result__));




extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () __attribute__ ((__warn_unused_result__));






extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
      int __modes, size_t __n) throw ();





extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
         size_t __size) throw ();


extern void setlinebuf (FILE *__stream) throw ();








extern int fprintf (FILE *__restrict __stream,
      __const char *__restrict __format, ...);




extern int printf (__const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,
      __const char *__restrict __format, ...) throw ();





extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
       __gnuc_va_list __arg);




extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);

extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
       __gnuc_va_list __arg) throw ();





extern int snprintf (char *__restrict __s, size_t __maxlen,
       __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
        __const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 3, 0)));






extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
        __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 2, 0))) __attribute__ ((__warn_unused_result__));
extern int __asprintf (char **__restrict __ptr,
         __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
extern int asprintf (char **__restrict __ptr,
       __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
# 394 "/usr/include/stdio.h" 3 4
extern int vdprintf (int __fd, __const char *__restrict __fmt,
       __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));








extern int fscanf (FILE *__restrict __stream,
     __const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));




extern int scanf (__const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));

extern int sscanf (__const char *__restrict __s,
     __const char *__restrict __format, ...) throw ();
# 445 "/usr/include/stdio.h" 3 4








extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
      __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__));





extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__));


extern int vsscanf (__const char *__restrict __s,
      __const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
# 504 "/usr/include/stdio.h" 3 4









extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);





extern int getchar (void);

# 532 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 543 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);











extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);





extern int putchar (int __c);

# 576 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream);


extern int putw (int __w, FILE *__stream);








extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
     __attribute__ ((__warn_unused_result__));






extern char *gets (char *__s) __attribute__ ((__warn_unused_result__));

# 622 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
# 638 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
          size_t *__restrict __n, int __delimiter,
          FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern __ssize_t getdelim (char **__restrict __lineptr,
        size_t *__restrict __n, int __delimiter,
        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));







extern __ssize_t getline (char **__restrict __lineptr,
       size_t *__restrict __n,
       FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));








extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);





extern int puts (__const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
       size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));




extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
        size_t __n, FILE *__restrict __s) __attribute__ ((__warn_unused_result__));

# 699 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (__const char *__restrict __s,
      FILE *__restrict __stream);
# 710 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
         size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
          size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));








extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream) __attribute__ ((__warn_unused_result__));




extern void rewind (FILE *__stream);

# 746 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);




extern __off_t ftello (FILE *__stream) __attribute__ ((__warn_unused_result__));
# 765 "/usr/include/stdio.h" 3 4






extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);




extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
# 788 "/usr/include/stdio.h" 3 4



extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__warn_unused_result__));
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);




extern void clearerr (FILE *__stream) throw ();

extern int feof (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));

extern int ferror (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));




extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
extern int ferror_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));








extern void perror (__const char *__s);






# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 27 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern __const char *__const sys_errlist[];


extern int _sys_nerr;
extern __const char *__const _sys_errlist[];
# 827 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));




extern int fileno_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
# 846 "/usr/include/stdio.h" 3 4
extern FILE *popen (__const char *__command, __const char *__modes) __attribute__ ((__warn_unused_result__));





extern int pclose (FILE *__stream);





extern char *ctermid (char *__s) throw ();





extern char *cuserid (char *__s);




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
      __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
       __const char *__restrict __format,
       __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));







extern void flockfile (FILE *__stream) throw ();



extern int ftrylockfile (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));


extern void funlockfile (FILE *__stream) throw ();
# 907 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 44 "/usr/include/bits/stdio.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
getchar (void)
{
  return _IO_getc (stdin);
}




extern __inline __attribute__ ((__gnu_inline__)) int
fgetc_unlocked (FILE *__fp)
{
  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}





extern __inline __attribute__ ((__gnu_inline__)) int
getc_unlocked (FILE *__fp)
{
  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


extern __inline __attribute__ ((__gnu_inline__)) int
getchar_unlocked (void)
{
  return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




extern __inline __attribute__ ((__gnu_inline__)) int
putchar (int __c)
{
  return _IO_putc (__c, stdout);
}




extern __inline __attribute__ ((__gnu_inline__)) int
fputc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





extern __inline __attribute__ ((__gnu_inline__)) int
putc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


extern __inline __attribute__ ((__gnu_inline__)) int
putchar_unlocked (int __c)
{
  return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}





extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
  return __getdelim (__lineptr, __n, '\n', __stream);
}





extern __inline __attribute__ ((__gnu_inline__)) int
feof_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x10) != 0);
}


extern __inline __attribute__ ((__gnu_inline__)) int
ferror_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x20) != 0);
}
# 908 "/usr/include/stdio.h" 2 3 4


# 1 "/usr/include/bits/stdio2.h" 1 3 4
# 24 "/usr/include/bits/stdio2.h" 3 4
extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
     __const char *__restrict __format, ...) throw ();
extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen,
      __const char *__restrict __format,
      __gnuc_va_list __ap) throw ();


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
sprintf (char *__restrict __s, __const char *__restrict __fmt, ...) throw ()
{
  return __builtin___sprintf_chk (__s, 2 - 1,
      __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
}






extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
vsprintf (char *__restrict __s, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()

{
  return __builtin___vsprintf_chk (__s, 2 - 1,
       __builtin_object_size (__s, 2 > 1), __fmt, __ap);
}



extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag,
      size_t __slen, __const char *__restrict __format,
      ...) throw ();
extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag,
       size_t __slen, __const char *__restrict __format,
       __gnuc_va_list __ap) throw ();


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
snprintf (char *__restrict __s, size_t __n, __const char *__restrict __fmt, ...) throw ()

{
  return __builtin___snprintf_chk (__s, __n, 2 - 1,
       __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
}






extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
vsnprintf (char *__restrict __s, size_t __n, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()

{
  return __builtin___vsnprintf_chk (__s, __n, 2 - 1,
        __builtin_object_size (__s, 2 > 1), __fmt, __ap);
}





extern int __fprintf_chk (FILE *__restrict __stream, int __flag,
     __const char *__restrict __format, ...);
extern int __printf_chk (int __flag, __const char *__restrict __format, ...);
extern int __vfprintf_chk (FILE *__restrict __stream, int __flag,
      __const char *__restrict __format, __gnuc_va_list __ap);
extern int __vprintf_chk (int __flag, __const char *__restrict __format,
     __gnuc_va_list __ap);


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
fprintf (FILE *__restrict __stream, __const char *__restrict __fmt, ...)
{
  return __fprintf_chk (__stream, 2 - 1, __fmt,
   __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
printf (__const char *__restrict __fmt, ...)
{
  return __printf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
}







extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __ap)
{

  return __vfprintf_chk (stdout, 2 - 1, __fmt, __ap);



}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
vfprintf (FILE *__restrict __stream,
   __const char *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vfprintf_chk (__stream, 2 - 1, __fmt, __ap);
}



extern int __asprintf_chk (char **__restrict __ptr, int __flag,
      __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4))) __attribute__ ((__warn_unused_result__));
extern int __vasprintf_chk (char **__restrict __ptr, int __flag,
       __const char *__restrict __fmt, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 3, 0))) __attribute__ ((__warn_unused_result__));
extern int __dprintf_chk (int __fd, int __flag, __const char *__restrict __fmt,
     ...) __attribute__ ((__format__ (__printf__, 3, 4)));
extern int __vdprintf_chk (int __fd, int __flag,
      __const char *__restrict __fmt, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 3, 0)));
extern int __obstack_printf_chk (struct obstack *__restrict __obstack,
     int __flag, __const char *__restrict __format,
     ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack,
      int __flag,
      __const char *__restrict __format,
      __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 3, 0)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
asprintf (char **__restrict __ptr, __const char *__restrict __fmt, ...) throw ()
{
  return __asprintf_chk (__ptr, 2 - 1, __fmt,
    __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
__asprintf (char **__restrict __ptr, __const char *__restrict __fmt, ...) throw ()

{
  return __asprintf_chk (__ptr, 2 - 1, __fmt,
    __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
dprintf (int __fd, __const char *__restrict __fmt, ...)
{
  return __dprintf_chk (__fd, 2 - 1, __fmt,
   __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
obstack_printf (struct obstack *__restrict __obstack, __const char *__restrict __fmt, ...) throw ()

{
  return __obstack_printf_chk (__obstack, 2 - 1, __fmt,
          __builtin_va_arg_pack ());
}
# 195 "/usr/include/bits/stdio2.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
vasprintf (char **__restrict __ptr, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()

{
  return __vasprintf_chk (__ptr, 2 - 1, __fmt, __ap);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
vdprintf (int __fd, __const char *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vdprintf_chk (__fd, 2 - 1, __fmt, __ap);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
obstack_vprintf (struct obstack *__restrict __obstack, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()

{
  return __obstack_vprintf_chk (__obstack, 2 - 1, __fmt,
    __ap);
}





extern char *__gets_chk (char *__str, size_t) __attribute__ ((__warn_unused_result__));
extern char *__gets_warn (char *__str) __asm__ ("" "gets")
     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use fgets or getline instead, gets can't " "specify buffer size")))
                               ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
gets (char *__str)
{
  if (__builtin_object_size (__str, 2 > 1) != (size_t) -1)
    return __gets_chk (__str, __builtin_object_size (__str, 2 > 1));
  return __gets_warn (__str);
}

extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
     FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets")

                                        __attribute__ ((__warn_unused_result__));
extern char *__fgets_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets called with bigger size than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n) || __n <= 0)
 return __fgets_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);

      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
 return __fgets_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
    }
  return __fgets_alias (__s, __n, __stream);
}

extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen,
      size_t __size, size_t __n,
      FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern size_t __fread_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread")


            __attribute__ ((__warn_unused_result__));
extern size_t __fread_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_chk")




     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread called with bigger size * nmemb than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) size_t
fread (void *__restrict __ptr, size_t __size, size_t __n,
       FILE *__restrict __stream)
{
  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size)
   || !__builtin_constant_p (__n)
   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
 return __fread_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);

      if (__size * __n > __builtin_object_size (__ptr, 0))
 return __fread_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
    }
  return __fread_alias (__ptr, __size, __n, __stream);
}


extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size,
       int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern char *__fgets_unlocked_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets_unlocked")

                                                 __attribute__ ((__warn_unused_result__));
extern char *__fgets_unlocked_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_unlocked_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets_unlocked called with bigger size than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream)
{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n) || __n <= 0)
 return __fgets_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);

      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
 return __fgets_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
    }
  return __fgets_unlocked_alias (__s, __n, __stream);
}




extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen,
        size_t __size, size_t __n,
        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern size_t __fread_unlocked_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread_unlocked")


                     __attribute__ ((__warn_unused_result__));
extern size_t __fread_unlocked_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_unlocked_chk")




     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread_unlocked called with bigger size * nmemb than " "length of destination buffer")))
                                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) size_t
fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n,
  FILE *__restrict __stream)
{
  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size)
   || !__builtin_constant_p (__n)
   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
 return __fread_unlocked_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
         __stream);

      if (__size * __n > __builtin_object_size (__ptr, 0))
 return __fread_unlocked_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
       __stream);
    }


  if (__builtin_constant_p (__size)
      && __builtin_constant_p (__n)
      && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2))
      && __size * __n <= 8)
    {
      size_t __cnt = __size * __n;
      char *__cptr = (char *) __ptr;
      if (__cnt == 0)
 return 0;

      for (; __cnt > 0; --__cnt)
 {
   int __c = (__builtin_expect (((__stream)->_IO_read_ptr >= (__stream)->_IO_read_end), 0) ? __uflow (__stream) : *(unsigned char *) (__stream)->_IO_read_ptr++);
   if (__c == (-1))
     break;
   *__cptr++ = __c;
 }
      return (__cptr - (char *) __ptr) / __size;
    }

  return __fread_unlocked_alias (__ptr, __size, __n, __stream);
}
# 911 "/usr/include/stdio.h" 2 3 4





}
# 34 "/usr/include/python2.6/Python.h" 2






# 1 "/usr/include/errno.h" 1 3 4
# 32 "/usr/include/errno.h" 3 4
extern "C" {



# 1 "/usr/include/bits/errno.h" 1 3 4
# 25 "/usr/include/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4



# 1 "/usr/include/asm/errno.h" 1 3 4
# 1 "/usr/include/asm-generic/errno.h" 1 3 4



# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
# 5 "/usr/include/asm-generic/errno.h" 2 3 4
# 1 "/usr/include/asm/errno.h" 2 3 4
# 5 "/usr/include/linux/errno.h" 2 3 4
# 26 "/usr/include/bits/errno.h" 2 3 4
# 43 "/usr/include/bits/errno.h" 3 4
extern int *__errno_location (void) throw () __attribute__ ((__const__));
# 37 "/usr/include/errno.h" 2 3 4
# 55 "/usr/include/errno.h" 3 4
extern char *program_invocation_name, *program_invocation_short_name;



}
# 69 "/usr/include/errno.h" 3 4
typedef int error_t;
# 41 "/usr/include/python2.6/Python.h" 2
# 56 "/usr/include/python2.6/Python.h"
# 1 "/usr/include/assert.h" 1 3 4
# 57 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/pyport.h" 1






# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stdint.h" 1 3 4


# 1 "/usr/include/stdint.h" 1 3 4
# 28 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/stdint.h" 2 3 4
# 49 "/usr/include/stdint.h" 3 4
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;

typedef unsigned int uint32_t;



typedef unsigned long int uint64_t;
# 66 "/usr/include/stdint.h" 3 4
typedef signed char int_least8_t;
typedef short int int_least16_t;
typedef int int_least32_t;

typedef long int int_least64_t;






typedef unsigned char uint_least8_t;
typedef unsigned short int uint_least16_t;
typedef unsigned int uint_least32_t;

typedef unsigned long int uint_least64_t;
# 91 "/usr/include/stdint.h" 3 4
typedef signed char int_fast8_t;

typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
# 104 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;

typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
# 123 "/usr/include/stdint.h" 3 4
typedef unsigned long int uintptr_t;
# 135 "/usr/include/stdint.h" 3 4
typedef long int intmax_t;
typedef unsigned long int uintmax_t;
# 4 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stdint.h" 2 3 4
# 8 "/usr/include/python2.6/pyport.h" 2
# 89 "/usr/include/python2.6/pyport.h"
typedef uintptr_t Py_uintptr_t;
typedef intptr_t Py_intptr_t;
# 113 "/usr/include/python2.6/pyport.h"
typedef ssize_t Py_ssize_t;
# 235 "/usr/include/python2.6/pyport.h"
# 1 "/usr/include/math.h" 1 3 4
# 30 "/usr/include/math.h" 3 4
extern "C" {



# 1 "/usr/include/bits/huge_val.h" 1 3 4
# 35 "/usr/include/math.h" 2 3 4

# 1 "/usr/include/bits/huge_valf.h" 1 3 4
# 37 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/huge_vall.h" 1 3 4
# 38 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/inf.h" 1 3 4
# 41 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/nan.h" 1 3 4
# 44 "/usr/include/math.h" 2 3 4



# 1 "/usr/include/bits/mathdef.h" 1 3 4
# 26 "/usr/include/bits/mathdef.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 27 "/usr/include/bits/mathdef.h" 2 3 4




typedef float float_t;
typedef double double_t;
# 48 "/usr/include/math.h" 2 3 4
# 71 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4


extern double acos (double __x) throw (); extern double __acos (double __x) throw ();

extern double asin (double __x) throw (); extern double __asin (double __x) throw ();

extern double atan (double __x) throw (); extern double __atan (double __x) throw ();

extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();


extern double cos (double __x) throw (); extern double __cos (double __x) throw ();

extern double sin (double __x) throw (); extern double __sin (double __x) throw ();

extern double tan (double __x) throw (); extern double __tan (double __x) throw ();




extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();

extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();

extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();




extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
                                                           ;





extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();

extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();

extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();







extern double exp (double __x) throw (); extern double __exp (double __x) throw ();


extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();


extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();


extern double log (double __x) throw (); extern double __log (double __x) throw ();


extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();


extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ();




extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();

extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();





extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();


extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();


extern double logb (double __x) throw (); extern double __logb (double __x) throw ();






extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();


extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();








extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();


extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();





extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();






extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();








extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));


extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));


extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));


extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();




extern int __isinf (double __value) throw () __attribute__ ((__const__));


extern int __finite (double __value) throw () __attribute__ ((__const__));





extern int isinf (double __value) throw () __attribute__ ((__const__));


extern int finite (double __value) throw () __attribute__ ((__const__));


extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();



extern double significand (double __x) throw (); extern double __significand (double __x) throw ();





extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));






extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnan (double __value) throw () __attribute__ ((__const__));



extern int isnan (double __value) throw () __attribute__ ((__const__));


extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();






extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();






extern double tgamma (double) throw (); extern double __tgamma (double) throw ();





extern double gamma (double) throw (); extern double __gamma (double) throw ();






extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();







extern double rint (double __x) throw (); extern double __rint (double __x) throw ();


extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));

extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));



extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();



extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();



extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();




extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();



extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();



extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));



extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));




extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();






extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();



extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();



extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();


extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw ();


extern double fmin (double __x, double __y) throw (); extern double __fmin (double __x, double __y) throw ();



extern int __fpclassify (double __value) throw ()
     __attribute__ ((__const__));


extern int __signbit (double __value) throw ()
     __attribute__ ((__const__));



extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();








extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
# 72 "/usr/include/math.h" 2 3 4
# 94 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4


extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();

extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();

extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();

extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();


extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();

extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();

extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();




extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();

extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();

extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();




extern void
 sincosf
# 82 "/usr/include/bits/mathcalls.h" 3 4
 (float __x, float *__sinx, float *__cosx) throw (); extern void
 __sincosf
# 82 "/usr/include/bits/mathcalls.h" 3 4
 (float __x, float *__sinx, float *__cosx) throw ()
                                                           ;





extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();

extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();

extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();







extern float expf (float __x) throw (); extern float __expf (float __x) throw ();


extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();


extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();


extern float logf (float __x) throw (); extern float __logf (float __x) throw ();


extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();


extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ();




extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();

extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();





extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();


extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();


extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();






extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();


extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();








extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();


extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();





extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();






extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();








extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));


extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));


extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));


extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();




extern int __isinff (float __value) throw () __attribute__ ((__const__));


extern int __finitef (float __value) throw () __attribute__ ((__const__));





extern int isinff (float __value) throw () __attribute__ ((__const__));


extern int finitef (float __value) throw () __attribute__ ((__const__));


extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();



extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();





extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));






extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnanf (float __value) throw () __attribute__ ((__const__));



extern int isnanf (float __value) throw () __attribute__ ((__const__));


extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();






extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();






extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();





extern float gammaf (float) throw (); extern float __gammaf (float) throw ();






extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();







extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();


extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));

extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));



extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();



extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();



extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();




extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();



extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();



extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));



extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));




extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();






extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();



extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();



extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();


extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw ();


extern float fminf (float __x, float __y) throw (); extern float __fminf (float __x, float __y) throw ();



extern int __fpclassifyf (float __value) throw ()
     __attribute__ ((__const__));


extern int __signbitf (float __value) throw ()
     __attribute__ ((__const__));



extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();








extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
# 95 "/usr/include/math.h" 2 3 4
# 141 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4


extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();

extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();

extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();

extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();


extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();

extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();

extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();




extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();

extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();

extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();




extern void
 sincosl
# 82 "/usr/include/bits/mathcalls.h" 3 4
 (long double __x, long double *__sinx, long double *__cosx) throw (); extern void
 __sincosl
# 82 "/usr/include/bits/mathcalls.h" 3 4
 (long double __x, long double *__sinx, long double *__cosx) throw ()
                                                           ;





extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();

extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();

extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();







extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();


extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();


extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();


extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();


extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();


extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ();




extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();

extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();





extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();


extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();


extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();






extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();


extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();








extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();


extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();





extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();






extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();








extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));


extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));


extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));


extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();




extern int __isinfl (long double __value) throw () __attribute__ ((__const__));


extern int __finitel (long double __value) throw () __attribute__ ((__const__));





extern int isinfl (long double __value) throw () __attribute__ ((__const__));


extern int finitel (long double __value) throw () __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();



extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();





extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));






extern long double nanl (__const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnanl (long double __value) throw () __attribute__ ((__const__));



extern int isnanl (long double __value) throw () __attribute__ ((__const__));


extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();






extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();






extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();





extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();






extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();







extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();


extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));

extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));



extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();



extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();



extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();




extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();



extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();



extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));



extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));




extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();






extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();



extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();



extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();


extern long double fmaxl (long double __x, long double __y) throw (); extern long double __fmaxl (long double __x, long double __y) throw ();


extern long double fminl (long double __x, long double __y) throw (); extern long double __fminl (long double __x, long double __y) throw ();



extern int __fpclassifyl (long double __value) throw ()
     __attribute__ ((__const__));


extern int __signbitl (long double __value) throw ()
     __attribute__ ((__const__));



extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();








extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
# 142 "/usr/include/math.h" 2 3 4
# 157 "/usr/include/math.h" 3 4
extern int signgam;
# 198 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN,

    FP_INFINITE,

    FP_ZERO,

    FP_SUBNORMAL,

    FP_NORMAL

  };
# 291 "/usr/include/math.h" 3 4
typedef enum
{
  _IEEE_ = -1,
  _SVID_,
  _XOPEN_,
  _POSIX_,
  _ISOC_
} _LIB_VERSION_TYPE;




extern _LIB_VERSION_TYPE _LIB_VERSION;
# 314 "/usr/include/math.h" 3 4
struct __exception



  {
    int type;
    char *name;
    double arg1;
    double arg2;
    double retval;
  };


extern int matherr (struct __exception *__exc) throw ();
# 416 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathinline.h" 1 3 4
# 25 "/usr/include/bits/mathinline.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 26 "/usr/include/bits/mathinline.h" 2 3 4
# 37 "/usr/include/bits/mathinline.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
__signbitf (float __x) throw ()
{




  int __m;
  __asm ("pmovmskb %1, %0" : "=r" (__m) : "x" (__x));
  return __m & 0x8;

}
extern __inline __attribute__ ((__gnu_inline__)) int
__signbit (double __x) throw ()
{




  int __m;
  __asm ("pmovmskb %1, %0" : "=r" (__m) : "x" (__x));
  return __m & 0x80;

}
extern __inline __attribute__ ((__gnu_inline__)) int
__signbitl (long double __x) throw ()
{
  __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
  return (__u.__i[2] & 0x8000) != 0;
}
# 417 "/usr/include/math.h" 2 3 4
# 472 "/usr/include/math.h" 3 4
}
# 236 "/usr/include/python2.6/pyport.h" 2






# 1 "/usr/include/sys/time.h" 1 3 4
# 29 "/usr/include/sys/time.h" 3 4
# 1 "/usr/include/bits/time.h" 1 3 4
# 30 "/usr/include/sys/time.h" 2 3 4
# 39 "/usr/include/sys/time.h" 3 4
extern "C" {
# 57 "/usr/include/sys/time.h" 3 4
struct timezone
  {
    int tz_minuteswest;
    int tz_dsttime;
  };

typedef struct timezone *__restrict __timezone_ptr_t;
# 73 "/usr/include/sys/time.h" 3 4
extern int gettimeofday (struct timeval *__restrict __tv,
    __timezone_ptr_t __tz) throw () __attribute__ ((__nonnull__ (1)));




extern int settimeofday (__const struct timeval *__tv,
    __const struct timezone *__tz)
     throw () __attribute__ ((__nonnull__ (1)));





extern int adjtime (__const struct timeval *__delta,
      struct timeval *__olddelta) throw ();




enum __itimer_which
  {

    ITIMER_REAL = 0,


    ITIMER_VIRTUAL = 1,



    ITIMER_PROF = 2

  };



struct itimerval
  {

    struct timeval it_interval;

    struct timeval it_value;
  };






typedef int __itimer_which_t;




extern int getitimer (__itimer_which_t __which,
        struct itimerval *__value) throw ();




extern int setitimer (__itimer_which_t __which,
        __const struct itimerval *__restrict __new,
        struct itimerval *__restrict __old) throw ();




extern int utimes (__const char *__file, __const struct timeval __tvp[2])
     throw () __attribute__ ((__nonnull__ (1)));



extern int lutimes (__const char *__file, __const struct timeval __tvp[2])
     throw () __attribute__ ((__nonnull__ (1)));


extern int futimes (int __fd, __const struct timeval __tvp[2]) throw ();






extern int futimesat (int __fd, __const char *__file,
        __const struct timeval __tvp[2]) throw ();
# 191 "/usr/include/sys/time.h" 3 4
}
# 243 "/usr/include/python2.6/pyport.h" 2
# 300 "/usr/include/python2.6/pyport.h"
# 1 "/usr/include/sys/stat.h" 1 3 4
# 105 "/usr/include/sys/stat.h" 3 4
extern "C" {

# 1 "/usr/include/bits/stat.h" 1 3 4
# 43 "/usr/include/bits/stat.h" 3 4
struct stat
  {
    __dev_t st_dev;




    __ino_t st_ino;







    __nlink_t st_nlink;
    __mode_t st_mode;

    __uid_t st_uid;
    __gid_t st_gid;

    int __pad0;

    __dev_t st_rdev;




    __off_t st_size;



    __blksize_t st_blksize;

    __blkcnt_t st_blocks;
# 88 "/usr/include/bits/stat.h" 3 4
    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 103 "/usr/include/bits/stat.h" 3 4
    long int __unused[3];
# 112 "/usr/include/bits/stat.h" 3 4
  };



struct stat64
  {
    __dev_t st_dev;

    __ino64_t st_ino;
    __nlink_t st_nlink;
    __mode_t st_mode;






    __uid_t st_uid;
    __gid_t st_gid;

    int __pad0;
    __dev_t st_rdev;
    __off_t st_size;





    __blksize_t st_blksize;
    __blkcnt64_t st_blocks;







    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 164 "/usr/include/bits/stat.h" 3 4
    long int __unused[3];



  };
# 108 "/usr/include/sys/stat.h" 2 3 4
# 209 "/usr/include/sys/stat.h" 3 4
extern int stat (__const char *__restrict __file,
   struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
# 228 "/usr/include/sys/stat.h" 3 4
extern int stat64 (__const char *__restrict __file,
     struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));







extern int fstatat (int __fd, __const char *__restrict __file,
      struct stat *__restrict __buf, int __flag)
     throw () __attribute__ ((__nonnull__ (2, 3)));
# 253 "/usr/include/sys/stat.h" 3 4
extern int fstatat64 (int __fd, __const char *__restrict __file,
        struct stat64 *__restrict __buf, int __flag)
     throw () __attribute__ ((__nonnull__ (2, 3)));







extern int lstat (__const char *__restrict __file,
    struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
# 276 "/usr/include/sys/stat.h" 3 4
extern int lstat64 (__const char *__restrict __file,
      struct stat64 *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern int chmod (__const char *__file, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));





extern int lchmod (__const char *__file, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));




extern int fchmod (int __fd, __mode_t __mode) throw ();





extern int fchmodat (int __fd, __const char *__file, __mode_t __mode,
       int __flag)
     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));






extern __mode_t umask (__mode_t __mask) throw ();




extern __mode_t getumask (void) throw ();



extern int mkdir (__const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));





extern int mkdirat (int __fd, __const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (2)));






extern int mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
     throw () __attribute__ ((__nonnull__ (1)));





extern int mknodat (int __fd, __const char *__path, __mode_t __mode,
      __dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));





extern int mkfifo (__const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));





extern int mkfifoat (int __fd, __const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (2)));





extern int utimensat (int __fd, __const char *__path,
        __const struct timespec __times[2],
        int __flags)
     throw () __attribute__ ((__nonnull__ (2)));




extern int futimens (int __fd, __const struct timespec __times[2]) throw ();
# 399 "/usr/include/sys/stat.h" 3 4
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
     throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat (int __ver, __const char *__filename,
      struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat (int __ver, __const char *__filename,
       struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat (int __ver, int __fildes, __const char *__filename,
         struct stat *__stat_buf, int __flag)
     throw () __attribute__ ((__nonnull__ (3, 4)));
# 432 "/usr/include/sys/stat.h" 3 4
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
     throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat64 (int __ver, __const char *__filename,
        struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat64 (int __ver, __const char *__filename,
         struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat64 (int __ver, int __fildes, __const char *__filename,
    struct stat64 *__stat_buf, int __flag)
     throw () __attribute__ ((__nonnull__ (3, 4)));

extern int __xmknod (int __ver, __const char *__path, __mode_t __mode,
       __dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));

extern int __xmknodat (int __ver, int __fd, __const char *__path,
         __mode_t __mode, __dev_t *__dev)
     throw () __attribute__ ((__nonnull__ (3, 5)));




extern __inline __attribute__ ((__gnu_inline__)) int
stat (__const char *__path, struct stat *__statbuf) throw ()
{
  return __xstat (1, __path, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
lstat (__const char *__path, struct stat *__statbuf) throw ()
{
  return __lxstat (1, __path, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
fstat (int __fd, struct stat *__statbuf) throw ()
{
  return __fxstat (1, __fd, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
fstatat (int __fd, __const char *__filename, struct stat *__statbuf, int __flag) throw ()

{
  return __fxstatat (1, __fd, __filename, __statbuf, __flag);
}



extern __inline __attribute__ ((__gnu_inline__)) int
mknod (__const char *__path, __mode_t __mode, __dev_t __dev) throw ()
{
  return __xmknod (0, __path, __mode, &__dev);
}



extern __inline __attribute__ ((__gnu_inline__)) int
mknodat (int __fd, __const char *__path, __mode_t __mode, __dev_t __dev) throw ()

{
  return __xmknodat (0, __fd, __path, __mode, &__dev);
}





extern __inline __attribute__ ((__gnu_inline__)) int
stat64 (__const char *__path, struct stat64 *__statbuf) throw ()
{
  return __xstat64 (1, __path, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
lstat64 (__const char *__path, struct stat64 *__statbuf) throw ()
{
  return __lxstat64 (1, __path, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
fstat64 (int __fd, struct stat64 *__statbuf) throw ()
{
  return __fxstat64 (1, __fd, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
fstatat64 (int __fd, __const char *__filename, struct stat64 *__statbuf, int __flag) throw ()

{
  return __fxstatat64 (1, __fd, __filename, __statbuf, __flag);
}






}
# 301 "/usr/include/python2.6/pyport.h" 2
# 322 "/usr/include/python2.6/pyport.h"
extern "C" {
# 698 "/usr/include/python2.6/pyport.h"
}
# 59 "/usr/include/python2.6/Python.h" 2
# 77 "/usr/include/python2.6/Python.h"
# 1 "/usr/include/python2.6/pymath.h" 1
# 78 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/pymem.h" 1
# 11 "/usr/include/python2.6/pymem.h"
extern "C" {
# 52 "/usr/include/python2.6/pymem.h"
void * PyMem_Malloc(size_t);
void * PyMem_Realloc(void *, size_t);
void PyMem_Free(void *);
# 119 "/usr/include/python2.6/pymem.h"
}
# 79 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/object.h" 1



extern "C" {
# 106 "/usr/include/python2.6/object.h"
typedef struct _object {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
} PyObject;

typedef struct {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
} PyVarObject;
# 133 "/usr/include/python2.6/object.h"
typedef PyObject * (*unaryfunc)(PyObject *);
typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
typedef int (*inquiry)(PyObject *);
typedef Py_ssize_t (*lenfunc)(PyObject *);
typedef int (*coercion)(PyObject **, PyObject **);
typedef PyObject *(*intargfunc)(PyObject *, int) __attribute__((__deprecated__));
typedef PyObject *(*intintargfunc)(PyObject *, int, int) __attribute__((__deprecated__));
typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
typedef int(*intobjargproc)(PyObject *, int, PyObject *);
typedef int(*intintobjargproc)(PyObject *, int, int, PyObject *);
typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);




typedef int (*getreadbufferproc)(PyObject *, int, void **);
typedef int (*getwritebufferproc)(PyObject *, int, void **);
typedef int (*getsegcountproc)(PyObject *, int *);
typedef int (*getcharbufferproc)(PyObject *, int, char **);

typedef Py_ssize_t (*readbufferproc)(PyObject *, Py_ssize_t, void **);
typedef Py_ssize_t (*writebufferproc)(PyObject *, Py_ssize_t, void **);
typedef Py_ssize_t (*segcountproc)(PyObject *, Py_ssize_t *);
typedef Py_ssize_t (*charbufferproc)(PyObject *, Py_ssize_t, char **);



typedef struct bufferinfo {
 void *buf;
 PyObject *obj;
        Py_ssize_t len;
        Py_ssize_t itemsize;

        int readonly;
        int ndim;
        char *format;
        Py_ssize_t *shape;
        Py_ssize_t *strides;
        Py_ssize_t *suboffsets;
        void *internal;
} Py_buffer;

typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
# 213 "/usr/include/python2.6/object.h"
typedef int (*objobjproc)(PyObject *, PyObject *);
typedef int (*visitproc)(PyObject *, void *);
typedef int (*traverseproc)(PyObject *, visitproc, void *);

typedef struct {
# 226 "/usr/include/python2.6/object.h"
 binaryfunc nb_add;
 binaryfunc nb_subtract;
 binaryfunc nb_multiply;
 binaryfunc nb_divide;
 binaryfunc nb_remainder;
 binaryfunc nb_divmod;
 ternaryfunc nb_power;
 unaryfunc nb_negative;
 unaryfunc nb_positive;
 unaryfunc nb_absolute;
 inquiry nb_nonzero;
 unaryfunc nb_invert;
 binaryfunc nb_lshift;
 binaryfunc nb_rshift;
 binaryfunc nb_and;
 binaryfunc nb_xor;
 binaryfunc nb_or;
 coercion nb_coerce;
 unaryfunc nb_int;
 unaryfunc nb_long;
 unaryfunc nb_float;
 unaryfunc nb_oct;
 unaryfunc nb_hex;

 binaryfunc nb_inplace_add;
 binaryfunc nb_inplace_subtract;
 binaryfunc nb_inplace_multiply;
 binaryfunc nb_inplace_divide;
 binaryfunc nb_inplace_remainder;
 ternaryfunc nb_inplace_power;
 binaryfunc nb_inplace_lshift;
 binaryfunc nb_inplace_rshift;
 binaryfunc nb_inplace_and;
 binaryfunc nb_inplace_xor;
 binaryfunc nb_inplace_or;



 binaryfunc nb_floor_divide;
 binaryfunc nb_true_divide;
 binaryfunc nb_inplace_floor_divide;
 binaryfunc nb_inplace_true_divide;


 unaryfunc nb_index;
} PyNumberMethods;

typedef struct {
 lenfunc sq_length;
 binaryfunc sq_concat;
 ssizeargfunc sq_repeat;
 ssizeargfunc sq_item;
 ssizessizeargfunc sq_slice;
 ssizeobjargproc sq_ass_item;
 ssizessizeobjargproc sq_ass_slice;
 objobjproc sq_contains;

 binaryfunc sq_inplace_concat;
 ssizeargfunc sq_inplace_repeat;
} PySequenceMethods;

typedef struct {
 lenfunc mp_length;
 binaryfunc mp_subscript;
 objobjargproc mp_ass_subscript;
} PyMappingMethods;

typedef struct {
 readbufferproc bf_getreadbuffer;
 writebufferproc bf_getwritebuffer;
 segcountproc bf_getsegcount;
 charbufferproc bf_getcharbuffer;
        getbufferproc bf_getbuffer;
 releasebufferproc bf_releasebuffer;
} PyBufferProcs;


typedef void (*freefunc)(void *);
typedef void (*destructor)(PyObject *);
typedef int (*printfunc)(PyObject *, FILE *, int);
typedef PyObject *(*getattrfunc)(PyObject *, char *);
typedef PyObject *(*getattrofunc)(PyObject *, PyObject *);
typedef int (*setattrfunc)(PyObject *, char *, PyObject *);
typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
typedef int (*cmpfunc)(PyObject *, PyObject *);
typedef PyObject *(*reprfunc)(PyObject *);
typedef long (*hashfunc)(PyObject *);
typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
typedef PyObject *(*getiterfunc) (PyObject *);
typedef PyObject *(*iternextfunc) (PyObject *);
typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);
typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);
typedef int (*initproc)(PyObject *, PyObject *, PyObject *);
typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *);
typedef PyObject *(*allocfunc)(struct _typeobject *, Py_ssize_t);

typedef struct _typeobject {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
 const char *tp_name;
 Py_ssize_t tp_basicsize, tp_itemsize;



 destructor tp_dealloc;
 printfunc tp_print;
 getattrfunc tp_getattr;
 setattrfunc tp_setattr;
 cmpfunc tp_compare;
 reprfunc tp_repr;



 PyNumberMethods *tp_as_number;
 PySequenceMethods *tp_as_sequence;
 PyMappingMethods *tp_as_mapping;



 hashfunc tp_hash;
 ternaryfunc tp_call;
 reprfunc tp_str;
 getattrofunc tp_getattro;
 setattrofunc tp_setattro;


 PyBufferProcs *tp_as_buffer;


 long tp_flags;

 const char *tp_doc;



 traverseproc tp_traverse;


 inquiry tp_clear;



 richcmpfunc tp_richcompare;


 Py_ssize_t tp_weaklistoffset;



 getiterfunc tp_iter;
 iternextfunc tp_iternext;


 struct PyMethodDef *tp_methods;
 struct PyMemberDef *tp_members;
 struct PyGetSetDef *tp_getset;
 struct _typeobject *tp_base;
 PyObject *tp_dict;
 descrgetfunc tp_descr_get;
 descrsetfunc tp_descr_set;
 Py_ssize_t tp_dictoffset;
 initproc tp_init;
 allocfunc tp_alloc;
 newfunc tp_new;
 freefunc tp_free;
 inquiry tp_is_gc;
 PyObject *tp_bases;
 PyObject *tp_mro;
 PyObject *tp_cache;
 PyObject *tp_subclasses;
 PyObject *tp_weaklist;
 destructor tp_del;


 unsigned int tp_version_tag;
# 409 "/usr/include/python2.6/object.h"
} PyTypeObject;



typedef struct _heaptypeobject {


 PyTypeObject ht_type;
 PyNumberMethods as_number;
 PyMappingMethods as_mapping;
 PySequenceMethods as_sequence;




 PyBufferProcs as_buffer;
 PyObject *ht_name, *ht_slots;

} PyHeapTypeObject;







int PyType_IsSubtype(PyTypeObject *, PyTypeObject *);



extern PyTypeObject PyType_Type;
extern PyTypeObject PyBaseObject_Type;
extern PyTypeObject PySuper_Type;





int PyType_Ready(PyTypeObject *);
PyObject * PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);
PyObject * PyType_GenericNew(PyTypeObject *,
            PyObject *, PyObject *);
PyObject * _PyType_Lookup(PyTypeObject *, PyObject *);
unsigned int PyType_ClearCache(void);
void PyType_Modified(PyTypeObject *);


int PyObject_Print(PyObject *, FILE *, int);
void _PyObject_Dump(PyObject *);
PyObject * PyObject_Repr(PyObject *);
PyObject * _PyObject_Str(PyObject *);
PyObject * PyObject_Str(PyObject *);


PyObject * PyObject_Unicode(PyObject *);

int PyObject_Compare(PyObject *, PyObject *);
PyObject * PyObject_RichCompare(PyObject *, PyObject *, int);
int PyObject_RichCompareBool(PyObject *, PyObject *, int);
PyObject * PyObject_GetAttrString(PyObject *, const char *);
int PyObject_SetAttrString(PyObject *, const char *, PyObject *);
int PyObject_HasAttrString(PyObject *, const char *);
PyObject * PyObject_GetAttr(PyObject *, PyObject *);
int PyObject_SetAttr(PyObject *, PyObject *, PyObject *);
int PyObject_HasAttr(PyObject *, PyObject *);
PyObject ** _PyObject_GetDictPtr(PyObject *);
PyObject * PyObject_SelfIter(PyObject *);
PyObject * PyObject_GenericGetAttr(PyObject *, PyObject *);
int PyObject_GenericSetAttr(PyObject *,
           PyObject *, PyObject *);
long PyObject_Hash(PyObject *);
long PyObject_HashNotImplemented(PyObject *);
int PyObject_IsTrue(PyObject *);
int PyObject_Not(PyObject *);
int PyCallable_Check(PyObject *);
int PyNumber_Coerce(PyObject **, PyObject **);
int PyNumber_CoerceEx(PyObject **, PyObject **);

void PyObject_ClearWeakRefs(PyObject *);


extern int _PyObject_SlotCompare(PyObject *, PyObject *);







PyObject * PyObject_Dir(PyObject *);



int Py_ReprEnter(PyObject *);
void Py_ReprLeave(PyObject *);


long _Py_HashDouble(double);
long _Py_HashPointer(void*);
# 806 "/usr/include/python2.6/object.h"
void Py_IncRef(PyObject *);
void Py_DecRef(PyObject *);







extern PyObject _Py_NoneStruct;
# 825 "/usr/include/python2.6/object.h"
extern PyObject _Py_NotImplementedStruct;
# 839 "/usr/include/python2.6/object.h"
extern int _Py_SwappedOp[];
# 951 "/usr/include/python2.6/object.h"
void _PyTrash_deposit_object(PyObject*);
void _PyTrash_destroy_chain(void);
extern int _PyTrash_delete_nesting;
extern PyObject * _PyTrash_delete_later;
# 971 "/usr/include/python2.6/object.h"
}
# 81 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/objimpl.h" 1
# 11 "/usr/include/python2.6/objimpl.h"
extern "C" {
# 97 "/usr/include/python2.6/objimpl.h"
void * PyObject_Malloc(size_t);
void * PyObject_Realloc(void *, size_t);
void PyObject_Free(void *);
# 143 "/usr/include/python2.6/objimpl.h"
PyObject * PyObject_Init(PyObject *, PyTypeObject *);
PyVarObject * PyObject_InitVar(PyVarObject *,
                                                 PyTypeObject *, Py_ssize_t);
PyObject * _PyObject_New(PyTypeObject *);
PyVarObject * _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
# 228 "/usr/include/python2.6/objimpl.h"
Py_ssize_t PyGC_Collect(void);
# 237 "/usr/include/python2.6/objimpl.h"
PyVarObject * _PyObject_GC_Resize(PyVarObject *, Py_ssize_t);







typedef union _gc_head {
 struct {
  union _gc_head *gc_next;
  union _gc_head *gc_prev;
  Py_ssize_t gc_refs;
 } gc;
 long double dummy;
} PyGC_Head;

extern PyGC_Head *_PyGC_generation0;
# 288 "/usr/include/python2.6/objimpl.h"
PyObject * _PyObject_GC_Malloc(size_t);
PyObject * _PyObject_GC_New(PyTypeObject *);
PyVarObject * _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t);
void PyObject_GC_Track(void *);
void PyObject_GC_UnTrack(void *);
void PyObject_GC_Del(void *);
# 334 "/usr/include/python2.6/objimpl.h"
}
# 82 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/pydebug.h" 1




extern "C" {


extern int Py_DebugFlag;
extern int Py_VerboseFlag;
extern int Py_InteractiveFlag;
extern int Py_InspectFlag;
extern int Py_OptimizeFlag;
extern int Py_NoSiteFlag;
extern int Py_BytesWarningFlag;
extern int Py_UseClassExceptionsFlag;
extern int Py_FrozenFlag;
extern int Py_TabcheckFlag;
extern int Py_UnicodeFlag;
extern int Py_IgnoreEnvironmentFlag;
extern int Py_DivisionWarningFlag;
extern int Py_DontWriteBytecodeFlag;
extern int Py_NoUserSiteDirectory;



extern int _Py_QnewFlag;

extern int Py_Py3kWarningFlag;






void Py_FatalError(const char *message);


}
# 84 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/unicodeobject.h" 1
# 120 "/usr/include/python2.6/unicodeobject.h"
# 1 "/usr/include/wchar.h" 1 3 4
# 121 "/usr/include/python2.6/unicodeobject.h" 2







typedef unsigned int Py_UCS4;
# 137 "/usr/include/python2.6/unicodeobject.h"
typedef Py_UCS4 Py_UNICODE;
# 410 "/usr/include/python2.6/unicodeobject.h"
extern "C" {




typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    Py_ssize_t length;
    Py_UNICODE *str;
    long hash;
    PyObject *defenc;


} PyUnicodeObject;

extern PyTypeObject PyUnicode_Type;
# 464 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_FromUnicode(
    const Py_UNICODE *u,
    Py_ssize_t size
    );


PyObject* PyUnicodeUCS4_FromStringAndSize(
    const char *u,
    Py_ssize_t size
    );



PyObject* PyUnicodeUCS4_FromString(
    const char *u
    );




Py_UNICODE * PyUnicodeUCS4_AsUnicode(
    PyObject *unicode
    );



Py_ssize_t PyUnicodeUCS4_GetSize(
    PyObject *unicode
    );


Py_UNICODE PyUnicodeUCS4_GetMax(void);
# 511 "/usr/include/python2.6/unicodeobject.h"
int PyUnicodeUCS4_Resize(
    PyObject **unicode,
    Py_ssize_t length
    );
# 533 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_FromEncodedObject(
    register PyObject *obj,
    const char *encoding,
    const char *errors
    );
# 552 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_FromObject(
    register PyObject *obj
    );

PyObject * PyUnicodeUCS4_FromFormatV(const char*, va_list);
PyObject * PyUnicodeUCS4_FromFormat(const char*, ...);



PyObject * _PyUnicode_FormatAdvanced(PyObject *obj,
       Py_UNICODE *format_spec,
       Py_ssize_t format_spec_len);
# 574 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_FromWideChar(
    register const wchar_t *w,
    Py_ssize_t size
    );
# 591 "/usr/include/python2.6/unicodeobject.h"
Py_ssize_t PyUnicodeUCS4_AsWideChar(
    PyUnicodeObject *unicode,
    register wchar_t *w,
    Py_ssize_t size
    );
# 609 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_FromOrdinal(int ordinal);
# 620 "/usr/include/python2.6/unicodeobject.h"
int PyUnicodeUCS4_ClearFreelist(void);
# 656 "/usr/include/python2.6/unicodeobject.h"
PyObject * _PyUnicodeUCS4_AsDefaultEncodedString(
    PyObject *, const char *);
# 668 "/usr/include/python2.6/unicodeobject.h"
const char* PyUnicodeUCS4_GetDefaultEncoding(void);







int PyUnicodeUCS4_SetDefaultEncoding(
    const char *encoding
    );






PyObject* PyUnicodeUCS4_Decode(
    const char *s,
    Py_ssize_t size,
    const char *encoding,
    const char *errors
    );




PyObject* PyUnicodeUCS4_Encode(
    const Py_UNICODE *s,
    Py_ssize_t size,
    const char *encoding,
    const char *errors
    );




PyObject* PyUnicodeUCS4_AsEncodedObject(
    PyObject *unicode,
    const char *encoding,
    const char *errors
    );




PyObject* PyUnicodeUCS4_AsEncodedString(
    PyObject *unicode,
    const char *encoding,
    const char *errors
    );

PyObject* PyUnicode_BuildEncodingMap(
    PyObject* string
   );




PyObject* PyUnicode_DecodeUTF7(
    const char *string,
    Py_ssize_t length,
    const char *errors
    );

PyObject* PyUnicode_DecodeUTF7Stateful(
    const char *string,
    Py_ssize_t length,
    const char *errors,
    Py_ssize_t *consumed
    );

PyObject* PyUnicode_EncodeUTF7(
    const Py_UNICODE *data,
    Py_ssize_t length,
    int encodeSetO,

    int encodeWhiteSpace,

    const char *errors
    );



PyObject* PyUnicodeUCS4_DecodeUTF8(
    const char *string,
    Py_ssize_t length,
    const char *errors
    );

PyObject* PyUnicodeUCS4_DecodeUTF8Stateful(
    const char *string,
    Py_ssize_t length,
    const char *errors,
    Py_ssize_t *consumed
    );

PyObject* PyUnicodeUCS4_AsUTF8String(
    PyObject *unicode
    );

PyObject* PyUnicodeUCS4_EncodeUTF8(
    const Py_UNICODE *data,
    Py_ssize_t length,
    const char *errors
    );
# 800 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_DecodeUTF32(
    const char *string,
    Py_ssize_t length,
    const char *errors,
    int *byteorder


    );

PyObject* PyUnicodeUCS4_DecodeUTF32Stateful(
    const char *string,
    Py_ssize_t length,
    const char *errors,
    int *byteorder,


    Py_ssize_t *consumed
    );




PyObject* PyUnicodeUCS4_AsUTF32String(
    PyObject *unicode
    );
# 842 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_EncodeUTF32(
    const Py_UNICODE *data,
    Py_ssize_t length,
    const char *errors,
    int byteorder
    );
# 874 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_DecodeUTF16(
    const char *string,
    Py_ssize_t length,
    const char *errors,
    int *byteorder


    );

PyObject* PyUnicodeUCS4_DecodeUTF16Stateful(
    const char *string,
    Py_ssize_t length,
    const char *errors,
    int *byteorder,


    Py_ssize_t *consumed
    );




PyObject* PyUnicodeUCS4_AsUTF16String(
    PyObject *unicode
    );
# 920 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_EncodeUTF16(
    const Py_UNICODE *data,
    Py_ssize_t length,
    const char *errors,
    int byteorder
    );



PyObject* PyUnicodeUCS4_DecodeUnicodeEscape(
    const char *string,
    Py_ssize_t length,
    const char *errors
    );

PyObject* PyUnicodeUCS4_AsUnicodeEscapeString(
    PyObject *unicode
    );

PyObject* PyUnicodeUCS4_EncodeUnicodeEscape(
    const Py_UNICODE *data,
    Py_ssize_t length
    );



PyObject* PyUnicodeUCS4_DecodeRawUnicodeEscape(
    const char *string,
    Py_ssize_t length,
    const char *errors
    );

PyObject* PyUnicodeUCS4_AsRawUnicodeEscapeString(
    PyObject *unicode
    );

PyObject* PyUnicodeUCS4_EncodeRawUnicodeEscape(
    const Py_UNICODE *data,
    Py_ssize_t length
    );





PyObject *_PyUnicode_DecodeUnicodeInternal(
    const char *string,
    Py_ssize_t length,
    const char *errors
    );







PyObject* PyUnicodeUCS4_DecodeLatin1(
    const char *string,
    Py_ssize_t length,
    const char *errors
    );

PyObject* PyUnicodeUCS4_AsLatin1String(
    PyObject *unicode
    );

PyObject* PyUnicodeUCS4_EncodeLatin1(
    const Py_UNICODE *data,
    Py_ssize_t length,
    const char *errors
    );







PyObject* PyUnicodeUCS4_DecodeASCII(
    const char *string,
    Py_ssize_t length,
    const char *errors
    );

PyObject* PyUnicodeUCS4_AsASCIIString(
    PyObject *unicode
    );

PyObject* PyUnicodeUCS4_EncodeASCII(
    const Py_UNICODE *data,
    Py_ssize_t length,
    const char *errors
    );
# 1037 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_DecodeCharmap(
    const char *string,
    Py_ssize_t length,
    PyObject *mapping,

    const char *errors
    );

PyObject* PyUnicodeUCS4_AsCharmapString(
    PyObject *unicode,
    PyObject *mapping

    );

PyObject* PyUnicodeUCS4_EncodeCharmap(
    const Py_UNICODE *data,
    Py_ssize_t length,
    PyObject *mapping,

    const char *errors
    );
# 1072 "/usr/include/python2.6/unicodeobject.h"
PyObject * PyUnicodeUCS4_TranslateCharmap(
    const Py_UNICODE *data,
    Py_ssize_t length,
    PyObject *table,
    const char *errors
    );
# 1132 "/usr/include/python2.6/unicodeobject.h"
int PyUnicodeUCS4_EncodeDecimal(
    Py_UNICODE *s,
    Py_ssize_t length,
    char *output,
    const char *errors
    );
# 1147 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_Concat(
    PyObject *left,
    PyObject *right
    );
# 1163 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_Split(
    PyObject *s,
    PyObject *sep,
    Py_ssize_t maxsplit
    );






PyObject* PyUnicodeUCS4_Splitlines(
    PyObject *s,
    int keepends
    );



PyObject* PyUnicodeUCS4_Partition(
    PyObject *s,
    PyObject *sep
    );




PyObject* PyUnicodeUCS4_RPartition(
    PyObject *s,
    PyObject *sep
    );
# 1207 "/usr/include/python2.6/unicodeobject.h"
PyObject* PyUnicodeUCS4_RSplit(
    PyObject *s,
    PyObject *sep,
    Py_ssize_t maxsplit
    );
# 1225 "/usr/include/python2.6/unicodeobject.h"
PyObject * PyUnicodeUCS4_Translate(
    PyObject *str,
    PyObject *table,
    const char *errors
    );




PyObject* PyUnicodeUCS4_Join(
    PyObject *separator,
    PyObject *seq
    );




Py_ssize_t PyUnicodeUCS4_Tailmatch(
    PyObject *str,
    PyObject *substr,
    Py_ssize_t start,
    Py_ssize_t end,
    int direction
    );





Py_ssize_t PyUnicodeUCS4_Find(
    PyObject *str,
    PyObject *substr,
    Py_ssize_t start,
    Py_ssize_t end,
    int direction
    );



Py_ssize_t PyUnicodeUCS4_Count(
    PyObject *str,
    PyObject *substr,
    Py_ssize_t start,
    Py_ssize_t end
    );




PyObject * PyUnicodeUCS4_Replace(
    PyObject *str,
    PyObject *substr,
    PyObject *replstr,
    Py_ssize_t maxcount

    );




int PyUnicodeUCS4_Compare(
    PyObject *left,
    PyObject *right
    );
# 1306 "/usr/include/python2.6/unicodeobject.h"
PyObject * PyUnicodeUCS4_RichCompare(
    PyObject *left,
    PyObject *right,
    int op
    );




PyObject * PyUnicodeUCS4_Format(
    PyObject *format,
    PyObject *args
    );







int PyUnicodeUCS4_Contains(
    PyObject *container,
    PyObject *element
    );


PyObject * _PyUnicode_XStrip(
    PyUnicodeObject *self,
    int striptype,
    PyObject *sepobj
    );





extern const unsigned char _Py_ascii_whitespace[];
# 1351 "/usr/include/python2.6/unicodeobject.h"
int _PyUnicodeUCS4_IsLowercase(
    Py_UNICODE ch
    );

int _PyUnicodeUCS4_IsUppercase(
    Py_UNICODE ch
    );

int _PyUnicodeUCS4_IsTitlecase(
    Py_UNICODE ch
    );

int _PyUnicodeUCS4_IsWhitespace(
    const Py_UNICODE ch
    );

int _PyUnicodeUCS4_IsLinebreak(
    const Py_UNICODE ch
    );

Py_UNICODE _PyUnicodeUCS4_ToLowercase(
    Py_UNICODE ch
    );

Py_UNICODE _PyUnicodeUCS4_ToUppercase(
    Py_UNICODE ch
    );

Py_UNICODE _PyUnicodeUCS4_ToTitlecase(
    Py_UNICODE ch
    );

int _PyUnicodeUCS4_ToDecimalDigit(
    Py_UNICODE ch
    );

int _PyUnicodeUCS4_ToDigit(
    Py_UNICODE ch
    );

double _PyUnicodeUCS4_ToNumeric(
    Py_UNICODE ch
    );

int _PyUnicodeUCS4_IsDecimalDigit(
    Py_UNICODE ch
    );

int _PyUnicodeUCS4_IsDigit(
    Py_UNICODE ch
    );

int _PyUnicodeUCS4_IsNumeric(
    Py_UNICODE ch
    );

int _PyUnicodeUCS4_IsAlpha(
    Py_UNICODE ch
    );


}
# 86 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/intobject.h" 1
# 20 "/usr/include/python2.6/intobject.h"
extern "C" {


typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    long ob_ival;
} PyIntObject;

extern PyTypeObject PyInt_Type;





PyObject * PyInt_FromString(char*, char**, int);

PyObject * PyInt_FromUnicode(Py_UNICODE*, Py_ssize_t, int);

PyObject * PyInt_FromLong(long);
PyObject * PyInt_FromSize_t(size_t);
PyObject * PyInt_FromSsize_t(Py_ssize_t);
long PyInt_AsLong(PyObject *);
Py_ssize_t PyInt_AsSsize_t(PyObject *);
unsigned long PyInt_AsUnsignedLongMask(PyObject *);

unsigned long long PyInt_AsUnsignedLongLongMask(PyObject *);


long PyInt_GetMax(void);
# 59 "/usr/include/python2.6/intobject.h"
unsigned long PyOS_strtoul(char *, char **, int);
long PyOS_strtol(char *, char **, int);


int PyInt_ClearFreeList(void);





PyObject* _PyInt_Format(PyIntObject* v, int base, int newstyle);



PyObject * _PyInt_FormatAdvanced(PyObject *obj,
          char *format_spec,
          Py_ssize_t format_spec_len);


}
# 87 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/boolobject.h" 1





extern "C" {



typedef PyIntObject PyBoolObject;

extern PyTypeObject PyBool_Type;







extern PyIntObject _Py_ZeroStruct, _Py_TrueStruct;
# 31 "/usr/include/python2.6/boolobject.h"
PyObject * PyBool_FromLong(long);


}
# 88 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/longobject.h" 1



extern "C" {





typedef struct _longobject PyLongObject;

extern PyTypeObject PyLong_Type;





PyObject * PyLong_FromLong(long);
PyObject * PyLong_FromUnsignedLong(unsigned long);
PyObject * PyLong_FromDouble(double);
PyObject * PyLong_FromSize_t(size_t);
PyObject * PyLong_FromSsize_t(Py_ssize_t);
long PyLong_AsLong(PyObject *);
unsigned long PyLong_AsUnsignedLong(PyObject *);
unsigned long PyLong_AsUnsignedLongMask(PyObject *);
Py_ssize_t PyLong_AsSsize_t(PyObject *);





extern int _PyLong_DigitValue[256];







double _PyLong_AsScaledDouble(PyObject *vv, int *e);

double PyLong_AsDouble(PyObject *);
PyObject * PyLong_FromVoidPtr(void *);
void * PyLong_AsVoidPtr(PyObject *);


PyObject * PyLong_FromLongLong(long long);
PyObject * PyLong_FromUnsignedLongLong(unsigned long long);
long long PyLong_AsLongLong(PyObject *);
unsigned long long PyLong_AsUnsignedLongLong(PyObject *);
unsigned long long PyLong_AsUnsignedLongLongMask(PyObject *);


PyObject * PyLong_FromString(char *, char **, int);

PyObject * PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int);






int _PyLong_Sign(PyObject *v);
# 73 "/usr/include/python2.6/longobject.h"
size_t _PyLong_NumBits(PyObject *v);
# 88 "/usr/include/python2.6/longobject.h"
PyObject * _PyLong_FromByteArray(
 const unsigned char* bytes, size_t n,
 int little_endian, int is_signed);
# 111 "/usr/include/python2.6/longobject.h"
int _PyLong_AsByteArray(PyLongObject* v,
 unsigned char* bytes, size_t n,
 int little_endian, int is_signed);






PyObject * _PyLong_Format(PyObject *aa, int base, int addL, int newstyle);



PyObject * _PyLong_FormatAdvanced(PyObject *obj,
           char *format_spec,
           Py_ssize_t format_spec_len);


}
# 89 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/floatobject.h" 1
# 11 "/usr/include/python2.6/floatobject.h"
extern "C" {


typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    double ob_fval;
} PyFloatObject;

extern PyTypeObject PyFloat_Type;
# 35 "/usr/include/python2.6/floatobject.h"
double PyFloat_GetMax(void);
double PyFloat_GetMin(void);
PyObject * PyFloat_GetInfo(void);




PyObject * PyFloat_FromString(PyObject*, char** junk);


PyObject * PyFloat_FromDouble(double);



double PyFloat_AsDouble(PyObject *);






void PyFloat_AsReprString(char*, PyFloatObject *v);






void PyFloat_AsString(char*, PyFloatObject *v);
# 97 "/usr/include/python2.6/floatobject.h"
int _PyFloat_Pack4(double x, unsigned char *p, int le);
int _PyFloat_Pack8(double x, unsigned char *p, int le);


int _PyFloat_Digits(char *buf, double v, int *signum);
void _PyFloat_DigitsInit(void);
# 112 "/usr/include/python2.6/floatobject.h"
double _PyFloat_Unpack4(const unsigned char *p, int le);
double _PyFloat_Unpack8(const unsigned char *p, int le);


int PyFloat_ClearFreeList(void);



PyObject * _PyFloat_FormatAdvanced(PyObject *obj,
            char *format_spec,
            Py_ssize_t format_spec_len);


}
# 90 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/complexobject.h" 1





extern "C" {


typedef struct {
    double real;
    double imag;
} Py_complex;
# 24 "/usr/include/python2.6/complexobject.h"
Py_complex _Py_c_sum(Py_complex, Py_complex);
Py_complex _Py_c_diff(Py_complex, Py_complex);
Py_complex _Py_c_neg(Py_complex);
Py_complex _Py_c_prod(Py_complex, Py_complex);
Py_complex _Py_c_quot(Py_complex, Py_complex);
Py_complex _Py_c_pow(Py_complex, Py_complex);
double _Py_c_abs(Py_complex);
# 40 "/usr/include/python2.6/complexobject.h"
typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    Py_complex cval;
} PyComplexObject;

extern PyTypeObject PyComplex_Type;




PyObject * PyComplex_FromCComplex(Py_complex);
PyObject * PyComplex_FromDoubles(double real, double imag);

double PyComplex_RealAsDouble(PyObject *op);
double PyComplex_ImagAsDouble(PyObject *op);
Py_complex PyComplex_AsCComplex(PyObject *op);


}
# 92 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/rangeobject.h" 1






extern "C" {
# 21 "/usr/include/python2.6/rangeobject.h"
extern PyTypeObject PyRange_Type;




}
# 94 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/stringobject.h" 1






extern "C" {
# 35 "/usr/include/python2.6/stringobject.h"
typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
    long ob_shash;
    int ob_sstate;
    char ob_sval[1];
# 49 "/usr/include/python2.6/stringobject.h"
} PyStringObject;





extern PyTypeObject PyBaseString_Type;
extern PyTypeObject PyString_Type;





PyObject * PyString_FromStringAndSize(const char *, Py_ssize_t);
PyObject * PyString_FromString(const char *);
PyObject * PyString_FromFormatV(const char*, va_list)
    __attribute__((format(printf, 1, 0)));
PyObject * PyString_FromFormat(const char*, ...)
    __attribute__((format(printf, 1, 2)));
Py_ssize_t PyString_Size(PyObject *);
char * PyString_AsString(PyObject *);
PyObject * PyString_Repr(PyObject *, int);
void PyString_Concat(PyObject **, PyObject *);
void PyString_ConcatAndDel(PyObject **, PyObject *);
int _PyString_Resize(PyObject **, Py_ssize_t);
int _PyString_Eq(PyObject *, PyObject*);
PyObject * PyString_Format(PyObject *, PyObject *);
PyObject * _PyString_FormatLong(PyObject*, int, int,
        int, char**, int*);
PyObject * PyString_DecodeEscape(const char *, Py_ssize_t,
         const char *, Py_ssize_t,
         const char *);

void PyString_InternInPlace(PyObject **);
void PyString_InternImmortal(PyObject **);
PyObject * PyString_InternFromString(const char *);
void _Py_ReleaseInternedStrings(void);
# 96 "/usr/include/python2.6/stringobject.h"
PyObject * _PyString_Join(PyObject *sep, PyObject *x);






PyObject* PyString_Decode(
    const char *s,
    Py_ssize_t size,
    const char *encoding,
    const char *errors
    );




PyObject* PyString_Encode(
    const char *s,
    Py_ssize_t size,
    const char *encoding,
    const char *errors
    );




PyObject* PyString_AsEncodedObject(
    PyObject *str,
    const char *encoding,
    const char *errors
    );
# 137 "/usr/include/python2.6/stringobject.h"
PyObject* PyString_AsEncodedString(
    PyObject *str,
    const char *encoding,
    const char *errors
    );




PyObject* PyString_AsDecodedObject(
    PyObject *str,
    const char *encoding,
    const char *errors
    );
# 160 "/usr/include/python2.6/stringobject.h"
PyObject* PyString_AsDecodedString(
    PyObject *str,
    const char *encoding,
    const char *errors
    );







int PyString_AsStringAndSize(
    register PyObject *obj,
    register char **s,
    register Py_ssize_t *len


    );





int _PyString_InsertThousandsGrouping(char *buffer,
        Py_ssize_t n_buffer,
        Py_ssize_t n_digits,
        Py_ssize_t buf_size,
        Py_ssize_t *count,
        int append_zero_char);



PyObject * _PyBytes_FormatAdvanced(PyObject *obj,
            char *format_spec,
            Py_ssize_t format_spec_len);


}
# 95 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/bufferobject.h" 1
# 9 "/usr/include/python2.6/bufferobject.h"
extern "C" {



extern PyTypeObject PyBuffer_Type;





PyObject * PyBuffer_FromObject(PyObject *base,
                                           Py_ssize_t offset, Py_ssize_t size);
PyObject * PyBuffer_FromReadWriteObject(PyObject *base,
                                                    Py_ssize_t offset,
                                                    Py_ssize_t size);

PyObject * PyBuffer_FromMemory(void *ptr, Py_ssize_t size);
PyObject * PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size);

PyObject * PyBuffer_New(Py_ssize_t size);


}
# 97 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/bytesobject.h" 1
# 98 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/bytearrayobject.h" 1





extern "C" {
# 22 "/usr/include/python2.6/bytearrayobject.h"
typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;

    int ob_exports;
    Py_ssize_t ob_alloc;
    char *ob_bytes;
} PyByteArrayObject;


extern PyTypeObject PyByteArray_Type;
extern PyTypeObject PyByteArrayIter_Type;






PyObject * PyByteArray_FromObject(PyObject *);
PyObject * PyByteArray_Concat(PyObject *, PyObject *);
PyObject * PyByteArray_FromStringAndSize(const char *, Py_ssize_t);
Py_ssize_t PyByteArray_Size(PyObject *);
char * PyByteArray_AsString(PyObject *);
int PyByteArray_Resize(PyObject *, Py_ssize_t);







extern char _PyByteArray_empty_string[];


}
# 99 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/tupleobject.h" 1






extern "C" {
# 24 "/usr/include/python2.6/tupleobject.h"
typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
    PyObject *ob_item[1];





} PyTupleObject;

extern PyTypeObject PyTuple_Type;





PyObject * PyTuple_New(Py_ssize_t size);
Py_ssize_t PyTuple_Size(PyObject *);
PyObject * PyTuple_GetItem(PyObject *, Py_ssize_t);
int PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *);
PyObject * PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
int _PyTuple_Resize(PyObject **, Py_ssize_t);
PyObject * PyTuple_Pack(Py_ssize_t, ...);
# 55 "/usr/include/python2.6/tupleobject.h"
int PyTuple_ClearFreeList(void);


}
# 100 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/listobject.h" 1
# 19 "/usr/include/python2.6/listobject.h"
extern "C" {


typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;

    PyObject **ob_item;
# 38 "/usr/include/python2.6/listobject.h"
    Py_ssize_t allocated;
} PyListObject;

extern PyTypeObject PyList_Type;





PyObject * PyList_New(Py_ssize_t size);
Py_ssize_t PyList_Size(PyObject *);
PyObject * PyList_GetItem(PyObject *, Py_ssize_t);
int PyList_SetItem(PyObject *, Py_ssize_t, PyObject *);
int PyList_Insert(PyObject *, Py_ssize_t, PyObject *);
int PyList_Append(PyObject *, PyObject *);
PyObject * PyList_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
int PyList_SetSlice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
int PyList_Sort(PyObject *);
int PyList_Reverse(PyObject *);
PyObject * PyList_AsTuple(PyObject *);
PyObject * _PyList_Extend(PyListObject *, PyObject *);







}
# 101 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/dictobject.h" 1



extern "C" {
# 50 "/usr/include/python2.6/dictobject.h"
typedef struct {




 Py_ssize_t me_hash;
 PyObject *me_key;
 PyObject *me_value;
} PyDictEntry;
# 69 "/usr/include/python2.6/dictobject.h"
typedef struct _dictobject PyDictObject;
struct _dictobject {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
 Py_ssize_t ma_fill;
 Py_ssize_t ma_used;





 Py_ssize_t ma_mask;






 PyDictEntry *ma_table;
 PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
 PyDictEntry ma_smalltable[8];
};

extern PyTypeObject PyDict_Type;





PyObject * PyDict_New(void);
PyObject * PyDict_GetItem(PyObject *mp, PyObject *key);
int PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
int PyDict_DelItem(PyObject *mp, PyObject *key);
void PyDict_Clear(PyObject *mp);
int PyDict_Next(
 PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
int _PyDict_Next(
 PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash);
PyObject * PyDict_Keys(PyObject *mp);
PyObject * PyDict_Values(PyObject *mp);
PyObject * PyDict_Items(PyObject *mp);
Py_ssize_t PyDict_Size(PyObject *mp);
PyObject * PyDict_Copy(PyObject *mp);
int PyDict_Contains(PyObject *mp, PyObject *key);
int _PyDict_Contains(PyObject *mp, PyObject *key, long hash);
PyObject * _PyDict_NewPresized(Py_ssize_t minused);


int PyDict_Update(PyObject *mp, PyObject *other);






int PyDict_Merge(PyObject *mp,
       PyObject *other,
       int override);






int PyDict_MergeFromSeq2(PyObject *d,
        PyObject *seq2,
        int override);

PyObject * PyDict_GetItemString(PyObject *dp, const char *key);
int PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item);
int PyDict_DelItemString(PyObject *dp, const char *key);


}
# 102 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/enumobject.h" 1






extern "C" {


extern PyTypeObject PyEnum_Type;
extern PyTypeObject PyReversed_Type;


}
# 103 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/setobject.h" 1





extern "C" {
# 24 "/usr/include/python2.6/setobject.h"
typedef struct {
 long hash;
 PyObject *key;
} setentry;






typedef struct _setobject PySetObject;
struct _setobject {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type;

 Py_ssize_t fill;
 Py_ssize_t used;





 Py_ssize_t mask;





 setentry *table;
 setentry *(*lookup)(PySetObject *so, PyObject *key, long hash);
 setentry smalltable[8];

 long hash;
 PyObject *weakreflist;
};

extern PyTypeObject PySet_Type;
extern PyTypeObject PyFrozenSet_Type;
# 83 "/usr/include/python2.6/setobject.h"
PyObject * PySet_New(PyObject *);
PyObject * PyFrozenSet_New(PyObject *);
Py_ssize_t PySet_Size(PyObject *anyset);

int PySet_Clear(PyObject *set);
int PySet_Contains(PyObject *anyset, PyObject *key);
int PySet_Discard(PyObject *set, PyObject *key);
int PySet_Add(PyObject *set, PyObject *key);
int _PySet_Next(PyObject *set, Py_ssize_t *pos, PyObject **key);
int _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, long *hash);
PyObject * PySet_Pop(PyObject *set);
int _PySet_Update(PyObject *set, PyObject *iterable);


}
# 104 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/methodobject.h" 1






extern "C" {






extern PyTypeObject PyCFunction_Type;



typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
typedef PyObject *(*PyCFunctionWithKeywords)(PyObject *, PyObject *,
          PyObject *);
typedef PyObject *(*PyNoArgsFunction)(PyObject *);

PyCFunction PyCFunction_GetFunction(PyObject *);
PyObject * PyCFunction_GetSelf(PyObject *);
int PyCFunction_GetFlags(PyObject *);
# 35 "/usr/include/python2.6/methodobject.h"
PyObject * PyCFunction_Call(PyObject *, PyObject *, PyObject *);

struct PyMethodDef {
    const char *ml_name;
    PyCFunction ml_meth;
    int ml_flags;

    const char *ml_doc;
};
typedef struct PyMethodDef PyMethodDef;

PyObject * Py_FindMethod(PyMethodDef[], PyObject *, const char *);


PyObject * PyCFunction_NewEx(PyMethodDef *, PyObject *,
      PyObject *);
# 73 "/usr/include/python2.6/methodobject.h"
typedef struct PyMethodChain {
    PyMethodDef *methods;
    struct PyMethodChain *link;
} PyMethodChain;

PyObject * Py_FindMethodInChain(PyMethodChain *, PyObject *,
                                            const char *);

typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyMethodDef *m_ml;
    PyObject *m_self;
    PyObject *m_module;
} PyCFunctionObject;

int PyCFunction_ClearFreeList(void);


}
# 105 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/moduleobject.h" 1






extern "C" {


extern PyTypeObject PyModule_Type;




PyObject * PyModule_New(const char *);
PyObject * PyModule_GetDict(PyObject *);
char * PyModule_GetName(PyObject *);
char * PyModule_GetFilename(PyObject *);
void _PyModule_Clear(PyObject *);


}
# 106 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/funcobject.h" 1






extern "C" {
# 21 "/usr/include/python2.6/funcobject.h"
typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyObject *func_code;
    PyObject *func_globals;
    PyObject *func_defaults;
    PyObject *func_closure;
    PyObject *func_doc;
    PyObject *func_name;
    PyObject *func_dict;
    PyObject *func_weakreflist;
    PyObject *func_module;






} PyFunctionObject;

extern PyTypeObject PyFunction_Type;



PyObject * PyFunction_New(PyObject *, PyObject *);
PyObject * PyFunction_GetCode(PyObject *);
PyObject * PyFunction_GetGlobals(PyObject *);
PyObject * PyFunction_GetModule(PyObject *);
PyObject * PyFunction_GetDefaults(PyObject *);
int PyFunction_SetDefaults(PyObject *, PyObject *);
PyObject * PyFunction_GetClosure(PyObject *);
int PyFunction_SetClosure(PyObject *, PyObject *);
# 67 "/usr/include/python2.6/funcobject.h"
extern PyTypeObject PyClassMethod_Type;
extern PyTypeObject PyStaticMethod_Type;

PyObject * PyClassMethod_New(PyObject *);
PyObject * PyStaticMethod_New(PyObject *);


}
# 107 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/classobject.h" 1
# 9 "/usr/include/python2.6/classobject.h"
extern "C" {


typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyObject *cl_bases;
    PyObject *cl_dict;
    PyObject *cl_name;

    PyObject *cl_getattr;
    PyObject *cl_setattr;
    PyObject *cl_delattr;
} PyClassObject;

typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyClassObject *in_class;
    PyObject *in_dict;
    PyObject *in_weakreflist;
} PyInstanceObject;

typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyObject *im_func;
    PyObject *im_self;
    PyObject *im_class;
    PyObject *im_weakreflist;
} PyMethodObject;

extern PyTypeObject PyClass_Type, PyInstance_Type, PyMethod_Type;





PyObject * PyClass_New(PyObject *, PyObject *, PyObject *);
PyObject * PyInstance_New(PyObject *, PyObject *,
                                            PyObject *);
PyObject * PyInstance_NewRaw(PyObject *, PyObject *);
PyObject * PyMethod_New(PyObject *, PyObject *, PyObject *);

PyObject * PyMethod_Function(PyObject *);
PyObject * PyMethod_Self(PyObject *);
PyObject * PyMethod_Class(PyObject *);
# 64 "/usr/include/python2.6/classobject.h"
PyObject * _PyInstance_Lookup(PyObject *pinst, PyObject *name);
# 75 "/usr/include/python2.6/classobject.h"
int PyClass_IsSubclass(PyObject *, PyObject *);

int PyMethod_ClearFreeList(void);


}
# 108 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/fileobject.h" 1






extern "C" {


typedef struct {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
 FILE *f_fp;
 PyObject *f_name;
 PyObject *f_mode;
 int (*f_close)(FILE *);
 int f_softspace;
 int f_binary;

 char* f_buf;
 char* f_bufend;
 char* f_bufptr;
 char *f_setbuf;
 int f_univ_newline;
 int f_newlinetypes;
 int f_skipnextlf;
 PyObject *f_encoding;
 PyObject *f_errors;
 PyObject *weakreflist;
 int unlocked_count;

 int readable;
 int writable;
} PyFileObject;

extern PyTypeObject PyFile_Type;




PyObject * PyFile_FromString(char *, char *);
void PyFile_SetBufSize(PyObject *, int);
int PyFile_SetEncoding(PyObject *, const char *);
int PyFile_SetEncodingAndErrors(PyObject *, const char *, char *errors);
PyObject * PyFile_FromFile(FILE *, char *, char *,
                                             int (*)(FILE *));
FILE * PyFile_AsFile(PyObject *);
void PyFile_IncUseCount(PyFileObject *);
void PyFile_DecUseCount(PyFileObject *);
PyObject * PyFile_Name(PyObject *);
PyObject * PyFile_GetLine(PyObject *, int);
int PyFile_WriteObject(PyObject *, PyObject *, int);
int PyFile_SoftSpace(PyObject *, int);
int PyFile_WriteString(const char *, PyObject *);
int PyObject_AsFileDescriptor(PyObject *);




extern const char * Py_FileSystemDefaultEncoding;





char *Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *);
size_t Py_UniversalNewlineFread(char *, size_t, FILE *, PyObject *);




int _PyFile_SanitizeMode(char *mode);


}
# 109 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/cobject.h" 1
# 14 "/usr/include/python2.6/cobject.h"
extern "C" {


extern PyTypeObject PyCObject_Type;
# 27 "/usr/include/python2.6/cobject.h"
PyObject * PyCObject_FromVoidPtr(
 void *cobj, void (*destruct)(void*));







PyObject * PyCObject_FromVoidPtrAndDesc(
 void *cobj, void *desc, void (*destruct)(void*,void*));


void * PyCObject_AsVoidPtr(PyObject *);


void * PyCObject_GetDesc(PyObject *);


void * PyCObject_Import(char *module_name, char *cobject_name);


int PyCObject_SetVoidPtr(PyObject *self, void *cobj);


typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    void *cobject;
    void *desc;
    void (*destructor)(void *);
} PyCObject;



}
# 110 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/traceback.h" 1




extern "C" {


struct _frame;



typedef struct _traceback {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
 struct _traceback *tb_next;
 struct _frame *tb_frame;
 int tb_lasti;
 int tb_lineno;
} PyTracebackObject;

int PyTraceBack_Here(struct _frame *);
int PyTraceBack_Print(PyObject *, PyObject *);
int _Py_DisplaySourceLine(PyObject *, const char *, int, int);


extern PyTypeObject PyTraceBack_Type;



}
# 111 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/sliceobject.h" 1



extern "C" {




extern PyObject _Py_EllipsisObject;
# 22 "/usr/include/python2.6/sliceobject.h"
typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyObject *start, *stop, *step;
} PySliceObject;

extern PyTypeObject PySlice_Type;
extern PyTypeObject PyEllipsis_Type;



PyObject * PySlice_New(PyObject* start, PyObject* stop,
                                  PyObject* step);
PyObject * _PySlice_FromIndices(Py_ssize_t start, Py_ssize_t stop);
int PySlice_GetIndices(PySliceObject *r, Py_ssize_t length,
                                  Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
int PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length,
        Py_ssize_t *start, Py_ssize_t *stop,
        Py_ssize_t *step, Py_ssize_t *slicelength);


}
# 112 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/cellobject.h" 1





extern "C" {


typedef struct {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
 PyObject *ob_ref;
} PyCellObject;

extern PyTypeObject PyCell_Type;



PyObject * PyCell_New(PyObject *);
PyObject * PyCell_Get(PyObject *);
int PyCell_Set(PyObject *, PyObject *);





}
# 113 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/iterobject.h" 1




extern "C" {


extern PyTypeObject PySeqIter_Type;



PyObject * PySeqIter_New(PyObject *);

extern PyTypeObject PyCallIter_Type;



PyObject * PyCallIter_New(PyObject *, PyObject *);

}
# 114 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/genobject.h" 1






extern "C" {


struct _frame;

typedef struct {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type;



 struct _frame *gi_frame;


 int gi_running;


 PyObject *gi_code;


 PyObject *gi_weakreflist;
} PyGenObject;

extern PyTypeObject PyGen_Type;




PyObject * PyGen_New(struct _frame *);
int PyGen_NeedsFinalizing(PyGenObject *);


}
# 115 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/descrobject.h" 1




extern "C" {


typedef PyObject *(*getter)(PyObject *, void *);
typedef int (*setter)(PyObject *, PyObject *, void *);

typedef struct PyGetSetDef {
 char *name;
 getter get;
 setter set;
 char *doc;
 void *closure;
} PyGetSetDef;

typedef PyObject *(*wrapperfunc)(PyObject *self, PyObject *args,
     void *wrapped);

typedef PyObject *(*wrapperfunc_kwds)(PyObject *self, PyObject *args,
          void *wrapped, PyObject *kwds);

struct wrapperbase {
 char *name;
 int offset;
 void *function;
 wrapperfunc wrapper;
 char *doc;
 int flags;
 PyObject *name_strobj;
};
# 45 "/usr/include/python2.6/descrobject.h"
typedef struct {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
} PyDescrObject;

typedef struct {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
 PyMethodDef *d_method;
} PyMethodDescrObject;

typedef struct {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
 struct PyMemberDef *d_member;
} PyMemberDescrObject;

typedef struct {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
 PyGetSetDef *d_getset;
} PyGetSetDescrObject;

typedef struct {
 Py_ssize_t ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
 struct wrapperbase *d_base;
 void *d_wrapped;
} PyWrapperDescrObject;

extern PyTypeObject PyWrapperDescr_Type;
extern PyTypeObject PyDictProxy_Type;
extern PyTypeObject PyGetSetDescr_Type;
extern PyTypeObject PyMemberDescr_Type;

PyObject * PyDescr_NewMethod(PyTypeObject *, PyMethodDef *);
PyObject * PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *);
PyObject * PyDescr_NewMember(PyTypeObject *,
            struct PyMemberDef *);
PyObject * PyDescr_NewGetSet(PyTypeObject *,
            struct PyGetSetDef *);
PyObject * PyDescr_NewWrapper(PyTypeObject *,
      struct wrapperbase *, void *);


PyObject * PyDictProxy_New(PyObject *);
PyObject * PyWrapper_New(PyObject *, PyObject *);


extern PyTypeObject PyProperty_Type;

}
# 116 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/warnings.h" 1



extern "C" {


void _PyWarnings_Init(void);

int PyErr_WarnEx(PyObject *, const char *, Py_ssize_t);
int PyErr_WarnExplicit(PyObject *, const char *, const char *, int,
                                    const char *, PyObject *);
# 20 "/usr/include/python2.6/warnings.h"
}
# 117 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/weakrefobject.h" 1





extern "C" {



typedef struct _PyWeakReference PyWeakReference;




struct _PyWeakReference {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;





    PyObject *wr_object;


    PyObject *wr_callback;




    long hash;






    PyWeakReference *wr_prev;
    PyWeakReference *wr_next;
};

extern PyTypeObject _PyWeakref_RefType;
extern PyTypeObject _PyWeakref_ProxyType;
extern PyTypeObject _PyWeakref_CallableProxyType;
# 59 "/usr/include/python2.6/weakrefobject.h"
PyObject * PyWeakref_NewRef(PyObject *ob,
                                              PyObject *callback);
PyObject * PyWeakref_NewProxy(PyObject *ob,
                                                PyObject *callback);
PyObject * PyWeakref_GetObject(PyObject *ref);

Py_ssize_t _PyWeakref_GetWeakrefCount(PyWeakReference *head);

void _PyWeakref_ClearRef(PyWeakReference *self);





}
# 118 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/codecs.h" 1



extern "C" {
# 26 "/usr/include/python2.6/codecs.h"
int PyCodec_Register(
       PyObject *search_function
       );
# 48 "/usr/include/python2.6/codecs.h"
PyObject * _PyCodec_Lookup(
       const char *encoding
       );
# 62 "/usr/include/python2.6/codecs.h"
PyObject * PyCodec_Encode(
       PyObject *object,
       const char *encoding,
       const char *errors
       );
# 78 "/usr/include/python2.6/codecs.h"
PyObject * PyCodec_Decode(
       PyObject *object,
       const char *encoding,
       const char *errors
       );
# 94 "/usr/include/python2.6/codecs.h"
PyObject * PyCodec_Encoder(
       const char *encoding
       );



PyObject * PyCodec_Decoder(
       const char *encoding
       );



PyObject * PyCodec_IncrementalEncoder(
       const char *encoding,
       const char *errors
       );



PyObject * PyCodec_IncrementalDecoder(
       const char *encoding,
       const char *errors
       );



PyObject * PyCodec_StreamReader(
       const char *encoding,
       PyObject *stream,
       const char *errors
       );



PyObject * PyCodec_StreamWriter(
       const char *encoding,
       PyObject *stream,
       const char *errors
       );
# 142 "/usr/include/python2.6/codecs.h"
int PyCodec_RegisterError(const char *name, PyObject *error);




PyObject * PyCodec_LookupError(const char *name);


PyObject * PyCodec_StrictErrors(PyObject *exc);


PyObject * PyCodec_IgnoreErrors(PyObject *exc);


PyObject * PyCodec_ReplaceErrors(PyObject *exc);


PyObject * PyCodec_XMLCharRefReplaceErrors(PyObject *exc);


PyObject * PyCodec_BackslashReplaceErrors(PyObject *exc);


}
# 120 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/pyerrors.h" 1



extern "C" {




typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyObject *dict;
    PyObject *args;
    PyObject *message;
} PyBaseExceptionObject;

typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyObject *dict;
    PyObject *args;
    PyObject *message;
    PyObject *msg;
    PyObject *filename;
    PyObject *lineno;
    PyObject *offset;
    PyObject *text;
    PyObject *print_file_and_line;
} PySyntaxErrorObject;


typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyObject *dict;
    PyObject *args;
    PyObject *message;
    PyObject *encoding;
    PyObject *object;
    Py_ssize_t start;
    Py_ssize_t end;
    PyObject *reason;
} PyUnicodeErrorObject;


typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyObject *dict;
    PyObject *args;
    PyObject *message;
    PyObject *code;
} PySystemExitObject;

typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    PyObject *dict;
    PyObject *args;
    PyObject *message;
    PyObject *myerrno;
    PyObject *strerror;
    PyObject *filename;
} PyEnvironmentErrorObject;
# 76 "/usr/include/python2.6/pyerrors.h"
void PyErr_SetNone(PyObject *);
void PyErr_SetObject(PyObject *, PyObject *);
void PyErr_SetString(PyObject *, const char *);
PyObject * PyErr_Occurred(void);
void PyErr_Clear(void);
void PyErr_Fetch(PyObject **, PyObject **, PyObject **);
void PyErr_Restore(PyObject *, PyObject *, PyObject *);
# 91 "/usr/include/python2.6/pyerrors.h"
int PyErr_GivenExceptionMatches(PyObject *, PyObject *);
int PyErr_ExceptionMatches(PyObject *);
void PyErr_NormalizeException(PyObject**, PyObject**, PyObject**);
# 118 "/usr/include/python2.6/pyerrors.h"
extern PyObject * PyExc_BaseException;
extern PyObject * PyExc_Exception;
extern PyObject * PyExc_StopIteration;
extern PyObject * PyExc_GeneratorExit;
extern PyObject * PyExc_StandardError;
extern PyObject * PyExc_ArithmeticError;
extern PyObject * PyExc_LookupError;

extern PyObject * PyExc_AssertionError;
extern PyObject * PyExc_AttributeError;
extern PyObject * PyExc_EOFError;
extern PyObject * PyExc_FloatingPointError;
extern PyObject * PyExc_EnvironmentError;
extern PyObject * PyExc_IOError;
extern PyObject * PyExc_OSError;
extern PyObject * PyExc_ImportError;
extern PyObject * PyExc_IndexError;
extern PyObject * PyExc_KeyError;
extern PyObject * PyExc_KeyboardInterrupt;
extern PyObject * PyExc_MemoryError;
extern PyObject * PyExc_NameError;
extern PyObject * PyExc_OverflowError;
extern PyObject * PyExc_RuntimeError;
extern PyObject * PyExc_NotImplementedError;
extern PyObject * PyExc_SyntaxError;
extern PyObject * PyExc_IndentationError;
extern PyObject * PyExc_TabError;
extern PyObject * PyExc_ReferenceError;
extern PyObject * PyExc_SystemError;
extern PyObject * PyExc_SystemExit;
extern PyObject * PyExc_TypeError;
extern PyObject * PyExc_UnboundLocalError;
extern PyObject * PyExc_UnicodeError;
extern PyObject * PyExc_UnicodeEncodeError;
extern PyObject * PyExc_UnicodeDecodeError;
extern PyObject * PyExc_UnicodeTranslateError;
extern PyObject * PyExc_ValueError;
extern PyObject * PyExc_ZeroDivisionError;







extern PyObject * PyExc_BufferError;

extern PyObject * PyExc_MemoryErrorInst;
extern PyObject * PyExc_RecursionErrorInst;


extern PyObject * PyExc_Warning;
extern PyObject * PyExc_UserWarning;
extern PyObject * PyExc_DeprecationWarning;
extern PyObject * PyExc_PendingDeprecationWarning;
extern PyObject * PyExc_SyntaxWarning;
extern PyObject * PyExc_RuntimeWarning;
extern PyObject * PyExc_FutureWarning;
extern PyObject * PyExc_ImportWarning;
extern PyObject * PyExc_UnicodeWarning;
extern PyObject * PyExc_BytesWarning;




int PyErr_BadArgument(void);
PyObject * PyErr_NoMemory(void);
PyObject * PyErr_SetFromErrno(PyObject *);
PyObject * PyErr_SetFromErrnoWithFilenameObject(
 PyObject *, PyObject *);
PyObject * PyErr_SetFromErrnoWithFilename(PyObject *, char *);





PyObject * PyErr_Format(PyObject *, const char *, ...)
   __attribute__((format(printf, 2, 3)));
# 219 "/usr/include/python2.6/pyerrors.h"
void PyErr_BadInternalCall(void);
void _PyErr_BadInternalCall(char *filename, int lineno);





PyObject * PyErr_NewException(char *name, PyObject *base,
                                         PyObject *dict);
void PyErr_WriteUnraisable(PyObject *);


int PyErr_CheckSignals(void);
void PyErr_SetInterrupt(void);


int PySignal_SetWakeupFd(int fd);


void PyErr_SyntaxLocation(const char *, int);
PyObject * PyErr_ProgramText(const char *, int);






PyObject * PyUnicodeDecodeError_Create(
 const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);


PyObject * PyUnicodeEncodeError_Create(
 const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);


PyObject * PyUnicodeTranslateError_Create(
 const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);


PyObject * PyUnicodeEncodeError_GetEncoding(PyObject *);
PyObject * PyUnicodeDecodeError_GetEncoding(PyObject *);


PyObject * PyUnicodeEncodeError_GetObject(PyObject *);
PyObject * PyUnicodeDecodeError_GetObject(PyObject *);
PyObject * PyUnicodeTranslateError_GetObject(PyObject *);



int PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *);
int PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *);
int PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *);



int PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);
int PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);
int PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);



int PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *);
int PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *);
int PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *);



int PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);
int PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);
int PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);


PyObject * PyUnicodeEncodeError_GetReason(PyObject *);
PyObject * PyUnicodeDecodeError_GetReason(PyObject *);
PyObject * PyUnicodeTranslateError_GetReason(PyObject *);



int PyUnicodeEncodeError_SetReason(
 PyObject *, const char *);
int PyUnicodeDecodeError_SetReason(
 PyObject *, const char *);
int PyUnicodeTranslateError_SetReason(
 PyObject *, const char *);
# 321 "/usr/include/python2.6/pyerrors.h"
int PyOS_snprintf(char *str, size_t size, const char *format, ...)
   __attribute__((format(printf, 3, 4)));
int PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va)
   __attribute__((format(printf, 3, 0)));


}
# 121 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/pystate.h" 1







extern "C" {




struct _ts;
struct _is;

typedef struct _is {

    struct _is *next;
    struct _ts *tstate_head;

    PyObject *modules;
    PyObject *sysdict;
    PyObject *builtins;
    PyObject *modules_reloading;

    PyObject *codec_search_path;
    PyObject *codec_search_cache;
    PyObject *codec_error_registry;


    int dlopenflags;





} PyInterpreterState;




struct _frame;


typedef int (*Py_tracefunc)(PyObject *, struct _frame *, int, PyObject *);
# 56 "/usr/include/python2.6/pystate.h"
typedef struct _ts {


    struct _ts *next;
    PyInterpreterState *interp;

    struct _frame *frame;
    int recursion_depth;



    int tracing;
    int use_tracing;

    Py_tracefunc c_profilefunc;
    Py_tracefunc c_tracefunc;
    PyObject *c_profileobj;
    PyObject *c_traceobj;

    PyObject *curexc_type;
    PyObject *curexc_value;
    PyObject *curexc_traceback;

    PyObject *exc_type;
    PyObject *exc_value;
    PyObject *exc_traceback;

    PyObject *dict;







    int tick_counter;

    int gilstate_counter;

    PyObject *async_exc;
    long thread_id;



} PyThreadState;


PyInterpreterState * PyInterpreterState_New(void);
void PyInterpreterState_Clear(PyInterpreterState *);
void PyInterpreterState_Delete(PyInterpreterState *);

PyThreadState * PyThreadState_New(PyInterpreterState *);
PyThreadState * _PyThreadState_Prealloc(PyInterpreterState *);
void _PyThreadState_Init(PyThreadState *);
void PyThreadState_Clear(PyThreadState *);
void PyThreadState_Delete(PyThreadState *);

void PyThreadState_DeleteCurrent(void);


PyThreadState * PyThreadState_Get(void);
PyThreadState * PyThreadState_Swap(PyThreadState *);
PyObject * PyThreadState_GetDict(void);
int PyThreadState_SetAsyncExc(long, PyObject *);




extern PyThreadState * _PyThreadState_Current;







typedef
    enum {PyGILState_LOCKED, PyGILState_UNLOCKED}
        PyGILState_STATE;
# 157 "/usr/include/python2.6/pystate.h"
PyGILState_STATE PyGILState_Ensure(void);
# 167 "/usr/include/python2.6/pystate.h"
void PyGILState_Release(PyGILState_STATE);







PyThreadState * PyGILState_GetThisThreadState(void);




PyObject * _PyThread_CurrentFrames(void);



PyInterpreterState * PyInterpreterState_Head(void);
PyInterpreterState * PyInterpreterState_Next(PyInterpreterState *);
PyThreadState * PyInterpreterState_ThreadHead(PyInterpreterState *);
PyThreadState * PyThreadState_Next(PyThreadState *);

typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_);


extern PyThreadFrameGetter _PyThreadState_GetFrame;


}
# 123 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/pyarena.h" 1







extern "C" {


  typedef struct _arena PyArena;
# 35 "/usr/include/python2.6/pyarena.h"
  PyArena * PyArena_New(void);
  void PyArena_Free(PyArena *);
# 50 "/usr/include/python2.6/pyarena.h"
  void * PyArena_Malloc(PyArena *, size_t size);





  int PyArena_AddPyObject(PyArena *, PyObject *);


}
# 125 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/modsupport.h" 1




extern "C" {
# 23 "/usr/include/python2.6/modsupport.h"
PyObject * _Py_VaBuildValue_SizeT(const char *, va_list);


int PyArg_Parse(PyObject *, const char *, ...);
int PyArg_ParseTuple(PyObject *, const char *, ...) ;
int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
                                                  const char *, char **, ...);
int PyArg_UnpackTuple(PyObject *, const char *, Py_ssize_t, Py_ssize_t, ...);
PyObject * Py_BuildValue(const char *, ...);
PyObject * _Py_BuildValue_SizeT(const char *, ...);
int _PyArg_NoKeywords(const char *funcname, PyObject *kw);

int PyArg_VaParse(PyObject *, const char *, va_list);
int PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,
                                                  const char *, char **, va_list);
PyObject * Py_VaBuildValue(const char *, va_list);

int PyModule_AddObject(PyObject *, const char *, PyObject *);
int PyModule_AddIntConstant(PyObject *, const char *, long);
int PyModule_AddStringConstant(PyObject *, const char *, const char *);
# 117 "/usr/include/python2.6/modsupport.h"
PyObject * Py_InitModule4_64(const char *name, PyMethodDef *methods,
                                      const char *doc, PyObject *self,
                                      int apiver);
# 129 "/usr/include/python2.6/modsupport.h"
extern char * _Py_PackageContext;


}
# 126 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/pythonrun.h" 1






extern "C" {
# 18 "/usr/include/python2.6/pythonrun.h"
typedef struct {
 int cf_flags;
} PyCompilerFlags;

void Py_SetProgramName(char *);
char * Py_GetProgramName(void);

void Py_SetPythonHome(char *);
char * Py_GetPythonHome(void);

void Py_Initialize(void);
void Py_InitializeEx(int);
void Py_Finalize(void);
int Py_IsInitialized(void);
PyThreadState * Py_NewInterpreter(void);
void Py_EndInterpreter(PyThreadState *);

int PyRun_AnyFileFlags(FILE *, const char *, PyCompilerFlags *);
int PyRun_AnyFileExFlags(FILE *, const char *, int, PyCompilerFlags *);
int PyRun_SimpleStringFlags(const char *, PyCompilerFlags *);
int PyRun_SimpleFileExFlags(FILE *, const char *, int, PyCompilerFlags *);
int PyRun_InteractiveOneFlags(FILE *, const char *, PyCompilerFlags *);
int PyRun_InteractiveLoopFlags(FILE *, const char *, PyCompilerFlags *);

struct _mod * PyParser_ASTFromString(const char *, const char *,
       int, PyCompilerFlags *flags,
                                                 PyArena *);
struct _mod * PyParser_ASTFromFile(FILE *, const char *, int,
            char *, char *,
                                               PyCompilerFlags *, int *,
                                               PyArena *);




struct _node * PyParser_SimpleParseStringFlags(const char *, int,
         int);
struct _node * PyParser_SimpleParseFileFlags(FILE *, const char *,
       int, int);

PyObject * PyRun_StringFlags(const char *, int, PyObject *,
      PyObject *, PyCompilerFlags *);

PyObject * PyRun_FileExFlags(FILE *, const char *, int,
      PyObject *, PyObject *, int,
      PyCompilerFlags *);


PyObject * Py_CompileStringFlags(const char *, const char *, int,
          PyCompilerFlags *);
struct symtable * Py_SymtableString(const char *, const char *, int);

void PyErr_Print(void);
void PyErr_PrintEx(int);
void PyErr_Display(PyObject *, PyObject *, PyObject *);

int Py_AtExit(void (*func)(void));

void Py_Exit(int);

int Py_FdIsInteractive(FILE *, const char *);


int Py_Main(int argc, char **argv);
# 103 "/usr/include/python2.6/pythonrun.h"
char * Py_GetProgramFullPath(void);
char * Py_GetPrefix(void);
char * Py_GetExecPrefix(void);
char * Py_GetPath(void);


const char * Py_GetVersion(void);
const char * Py_GetPlatform(void);
const char * Py_GetCopyright(void);
const char * Py_GetCompiler(void);
const char * Py_GetBuildInfo(void);
const char * _Py_svnversion(void);
const char * Py_SubversionRevision(void);
const char * Py_SubversionShortBranch(void);


PyObject * _PyBuiltin_Init(void);
PyObject * _PySys_Init(void);
void _PyImport_Init(void);
void _PyExc_Init(void);
void _PyImportHooks_Init(void);
int _PyFrame_Init(void);
int _PyInt_Init(void);
void _PyFloat_Init(void);
int PyByteArray_Init(void);


void _PyExc_Fini(void);
void _PyImport_Fini(void);
void PyMethod_Fini(void);
void PyFrame_Fini(void);
void PyCFunction_Fini(void);
void PyDict_Fini(void);
void PyTuple_Fini(void);
void PyList_Fini(void);
void PySet_Fini(void);
void PyString_Fini(void);
void PyInt_Fini(void);
void PyFloat_Fini(void);
void PyOS_FiniInterrupts(void);
void PyByteArray_Fini(void);


char * PyOS_Readline(FILE *, FILE *, char *);
extern int (*PyOS_InputHook)(void);
extern char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, char *);
extern PyThreadState* _PyOS_ReadlineTState;
# 167 "/usr/include/python2.6/pythonrun.h"
typedef void (*PyOS_sighandler_t)(int);
PyOS_sighandler_t PyOS_getsig(int);
PyOS_sighandler_t PyOS_setsig(int, PyOS_sighandler_t);



}
# 127 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/ceval.h" 1



extern "C" {





PyObject * PyEval_CallObjectWithKeywords(
 PyObject *, PyObject *, PyObject *);



PyObject * PyEval_CallObject(PyObject *, PyObject *);





PyObject * PyEval_CallFunction(PyObject *obj,
                                           const char *format, ...);
PyObject * PyEval_CallMethod(PyObject *obj,
                                         const char *methodname,
                                         const char *format, ...);

void PyEval_SetProfile(Py_tracefunc, PyObject *);
void PyEval_SetTrace(Py_tracefunc, PyObject *);

struct _frame;

PyObject * PyEval_GetBuiltins(void);
PyObject * PyEval_GetGlobals(void);
PyObject * PyEval_GetLocals(void);
struct _frame * PyEval_GetFrame(void);
int PyEval_GetRestricted(void);




int PyEval_MergeCompilerFlags(PyCompilerFlags *cf);

int Py_FlushLine(void);

int Py_AddPendingCall(int (*func)(void *), void *arg);
int Py_MakePendingCalls(void);


void Py_SetRecursionLimit(int);
int Py_GetRecursionLimit(void);






int _Py_CheckRecursiveCall(char *where);
extern int _Py_CheckRecursionLimit;






const char * PyEval_GetFuncName(PyObject *);
const char * PyEval_GetFuncDesc(PyObject *);

PyObject * PyEval_GetCallStats(PyObject *);
PyObject * PyEval_EvalFrame(struct _frame *);
PyObject * PyEval_EvalFrameEx(struct _frame *f, int exc);


extern volatile int _Py_Ticker;
extern int _Py_CheckInterval;
# 121 "/usr/include/python2.6/ceval.h"
PyThreadState * PyEval_SaveThread(void);
void PyEval_RestoreThread(PyThreadState *);



int PyEval_ThreadsInitialized(void);
void PyEval_InitThreads(void);
void PyEval_AcquireLock(void);
void PyEval_ReleaseLock(void);
void PyEval_AcquireThread(PyThreadState *tstate);
void PyEval_ReleaseThread(PyThreadState *tstate);
void PyEval_ReInitThreads(void);
# 151 "/usr/include/python2.6/ceval.h"
int _PyEval_SliceIndex(PyObject *, Py_ssize_t *);



}
# 128 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/sysmodule.h" 1






extern "C" {


PyObject * PySys_GetObject(char *);
int PySys_SetObject(char *, PyObject *);
FILE * PySys_GetFile(char *, FILE *);
void PySys_SetArgv(int, char **);
void PySys_SetPath(char *);

void PySys_WriteStdout(const char *format, ...)
   __attribute__((format(printf, 1, 2)));
void PySys_WriteStderr(const char *format, ...)
   __attribute__((format(printf, 1, 2)));

extern PyObject * _PySys_TraceFunc, *_PySys_ProfileFunc;
extern int _PySys_CheckInterval;

void PySys_ResetWarnOptions(void);
void PySys_AddWarnOption(char *);
int PySys_HasWarnOptions(void);


}
# 129 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/intrcheck.h" 1




extern "C" {


int PyOS_InterruptOccurred(void);
void PyOS_InitInterrupts(void);
void PyOS_AfterFork(void);


}
# 130 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/import.h" 1






extern "C" {


long PyImport_GetMagicNumber(void);
PyObject * PyImport_ExecCodeModule(char *name, PyObject *co);
PyObject * PyImport_ExecCodeModuleEx(
 char *name, PyObject *co, char *pathname);
PyObject * PyImport_GetModuleDict(void);
PyObject * PyImport_AddModule(const char *name);
PyObject * PyImport_ImportModule(const char *name);
PyObject * PyImport_ImportModuleNoBlock(const char *);
PyObject * PyImport_ImportModuleLevel(char *name,
 PyObject *globals, PyObject *locals, PyObject *fromlist, int level);




PyObject * PyImport_GetImporter(PyObject *path);
PyObject * PyImport_Import(PyObject *name);
PyObject * PyImport_ReloadModule(PyObject *m);
void PyImport_Cleanup(void);
int PyImport_ImportFrozenModule(char *);


void _PyImport_AcquireLock(void);
int _PyImport_ReleaseLock(void);





struct filedescr * _PyImport_FindModule(
 const char *, PyObject *, char *, size_t, FILE **, PyObject **);
int _PyImport_IsScript(struct filedescr *);
void _PyImport_ReInitLock(void);

PyObject *_PyImport_FindExtension(char *, char *);
PyObject *_PyImport_FixupExtension(char *, char *);

struct _inittab {
    char *name;
    void (*initfunc)(void);
};

extern PyTypeObject PyNullImporter_Type;
extern struct _inittab * PyImport_Inittab;

int PyImport_AppendInittab(char *name, void (*initfunc)(void));
int PyImport_ExtendInittab(struct _inittab *newtab);

struct _frozen {
    char *name;
    unsigned char *code;
    int size;
};




extern struct _frozen * PyImport_FrozenModules;


}
# 131 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/abstract.h" 1



extern "C" {
# 231 "/usr/include/python2.6/abstract.h"
     int PyObject_Cmp(PyObject *o1, PyObject *o2, int *result);
# 304 "/usr/include/python2.6/abstract.h"
     PyObject * PyObject_Call(PyObject *callable_object,
      PyObject *args, PyObject *kw);
# 314 "/usr/include/python2.6/abstract.h"
     PyObject * PyObject_CallObject(PyObject *callable_object,
                                               PyObject *args);
# 326 "/usr/include/python2.6/abstract.h"
     PyObject * PyObject_CallFunction(PyObject *callable_object,
                                                 char *format, ...);
# 340 "/usr/include/python2.6/abstract.h"
     PyObject * PyObject_CallMethod(PyObject *o, char *m,
                                               char *format, ...);
# 352 "/usr/include/python2.6/abstract.h"
     PyObject * _PyObject_CallFunction_SizeT(PyObject *callable,
        char *format, ...);
     PyObject * _PyObject_CallMethod_SizeT(PyObject *o,
             char *name,
             char *format, ...);

     PyObject * PyObject_CallFunctionObjArgs(PyObject *callable,
                                                        ...);
# 370 "/usr/include/python2.6/abstract.h"
     PyObject * PyObject_CallMethodObjArgs(PyObject *o,
                                                      PyObject *m, ...);
# 413 "/usr/include/python2.6/abstract.h"
     PyObject * PyObject_Type(PyObject *o);







     Py_ssize_t PyObject_Size(PyObject *o);
# 433 "/usr/include/python2.6/abstract.h"
     Py_ssize_t PyObject_Length(PyObject *o);


     Py_ssize_t _PyObject_LengthHint(PyObject *o, Py_ssize_t);







     PyObject * PyObject_GetItem(PyObject *o, PyObject *key);
# 453 "/usr/include/python2.6/abstract.h"
     int PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v);







     int PyObject_DelItemString(PyObject *o, char *key);







     int PyObject_DelItem(PyObject *o, PyObject *key);






     int PyObject_AsCharBuffer(PyObject *obj,
       const char **buffer,
       Py_ssize_t *buffer_len);
# 492 "/usr/include/python2.6/abstract.h"
     int PyObject_CheckReadBuffer(PyObject *obj);
# 501 "/usr/include/python2.6/abstract.h"
     int PyObject_AsReadBuffer(PyObject *obj,
       const void **buffer,
       Py_ssize_t *buffer_len);
# 517 "/usr/include/python2.6/abstract.h"
     int PyObject_AsWriteBuffer(PyObject *obj,
        void **buffer,
        Py_ssize_t *buffer_len);
# 542 "/usr/include/python2.6/abstract.h"
     int PyObject_GetBuffer(PyObject *obj, Py_buffer *view,
     int flags);
# 552 "/usr/include/python2.6/abstract.h"
     void * PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);





     int PyBuffer_SizeFromFormat(const char *);






     int PyBuffer_ToContiguous(void *buf, Py_buffer *view,
            Py_ssize_t len, char fort);

     int PyBuffer_FromContiguous(Py_buffer *view, void *buf,
              Py_ssize_t len, char fort);
# 588 "/usr/include/python2.6/abstract.h"
     int PyObject_CopyData(PyObject *dest, PyObject *src);




     int PyBuffer_IsContiguous(Py_buffer *view, char fort);


     void PyBuffer_FillContiguousStrides(int ndims,
            Py_ssize_t *shape,
          Py_ssize_t *strides,
                                             int itemsize,
               char fort);







     int PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf,
                       Py_ssize_t len, int readonly,
           int flags);







     void PyBuffer_Release(Py_buffer *view);




     PyObject * PyObject_Format(PyObject* obj,
         PyObject *format_spec);







     PyObject * PyObject_GetIter(PyObject *);
# 641 "/usr/include/python2.6/abstract.h"
     PyObject * PyIter_Next(PyObject *);







     int PyNumber_Check(PyObject *o);
# 659 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Add(PyObject *o1, PyObject *o2);
# 668 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Subtract(PyObject *o1, PyObject *o2);
# 677 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Multiply(PyObject *o1, PyObject *o2);
# 687 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Divide(PyObject *o1, PyObject *o2);
# 696 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_FloorDivide(PyObject *o1, PyObject *o2);
# 706 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_TrueDivide(PyObject *o1, PyObject *o2);
# 716 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Remainder(PyObject *o1, PyObject *o2);
# 726 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Divmod(PyObject *o1, PyObject *o2);
# 736 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Power(PyObject *o1, PyObject *o2,
                                          PyObject *o3);
# 746 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Negative(PyObject *o);







     PyObject * PyNumber_Positive(PyObject *o);







     PyObject * PyNumber_Absolute(PyObject *o);







     PyObject * PyNumber_Invert(PyObject *o);
# 780 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Lshift(PyObject *o1, PyObject *o2);
# 790 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Rshift(PyObject *o1, PyObject *o2);
# 799 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_And(PyObject *o1, PyObject *o2);
# 809 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Xor(PyObject *o1, PyObject *o2);
# 819 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Or(PyObject *o1, PyObject *o2);
# 852 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Index(PyObject *o);






     Py_ssize_t PyNumber_AsSsize_t(PyObject *o, PyObject *exc);
# 870 "/usr/include/python2.6/abstract.h"
     PyObject * _PyNumber_ConvertIntegralToInt(
             PyObject *integral,
             const char* error_format);
# 882 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Int(PyObject *o);
# 891 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Long(PyObject *o);
# 900 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_Float(PyObject *o);
# 910 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2);
# 919 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2);
# 928 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2);
# 937 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceDivide(PyObject *o1, PyObject *o2);
# 946 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceFloorDivide(PyObject *o1,
             PyObject *o2);
# 957 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceTrueDivide(PyObject *o1,
            PyObject *o2);
# 968 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2);
# 977 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlacePower(PyObject *o1, PyObject *o2,
            PyObject *o3);
# 987 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2);
# 996 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2);
# 1005 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2);
# 1014 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceXor(PyObject *o1, PyObject *o2);
# 1023 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_InPlaceOr(PyObject *o1, PyObject *o2);
# 1033 "/usr/include/python2.6/abstract.h"
     PyObject * PyNumber_ToBase(PyObject *n, int base);
# 1044 "/usr/include/python2.6/abstract.h"
     int PySequence_Check(PyObject *o);
# 1054 "/usr/include/python2.6/abstract.h"
     Py_ssize_t PySequence_Size(PyObject *o);
# 1063 "/usr/include/python2.6/abstract.h"
     Py_ssize_t PySequence_Length(PyObject *o);



     PyObject * PySequence_Concat(PyObject *o1, PyObject *o2);
# 1076 "/usr/include/python2.6/abstract.h"
     PyObject * PySequence_Repeat(PyObject *o, Py_ssize_t count);
# 1085 "/usr/include/python2.6/abstract.h"
     PyObject * PySequence_GetItem(PyObject *o, Py_ssize_t i);






     PyObject * PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
# 1101 "/usr/include/python2.6/abstract.h"
     int PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v);
# 1110 "/usr/include/python2.6/abstract.h"
     int PySequence_DelItem(PyObject *o, Py_ssize_t i);







     int PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2,
                                        PyObject *v);







     int PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);







     PyObject * PySequence_Tuple(PyObject *o);







     PyObject * PySequence_List(PyObject *o);





     PyObject * PySequence_Fast(PyObject *o, const char* m);
# 1185 "/usr/include/python2.6/abstract.h"
     Py_ssize_t PySequence_Count(PyObject *o, PyObject *value);
# 1194 "/usr/include/python2.6/abstract.h"
     int PySequence_Contains(PyObject *seq, PyObject *ob);
# 1203 "/usr/include/python2.6/abstract.h"
     Py_ssize_t _PySequence_IterSearch(PyObject *seq,
          PyObject *obj, int operation);
# 1218 "/usr/include/python2.6/abstract.h"
     int PySequence_In(PyObject *o, PyObject *value);
# 1229 "/usr/include/python2.6/abstract.h"
     Py_ssize_t PySequence_Index(PyObject *o, PyObject *value);
# 1239 "/usr/include/python2.6/abstract.h"
     PyObject * PySequence_InPlaceConcat(PyObject *o1, PyObject *o2);
# 1248 "/usr/include/python2.6/abstract.h"
     PyObject * PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count);
# 1259 "/usr/include/python2.6/abstract.h"
     int PyMapping_Check(PyObject *o);
# 1268 "/usr/include/python2.6/abstract.h"
     Py_ssize_t PyMapping_Size(PyObject *o);
# 1278 "/usr/include/python2.6/abstract.h"
     Py_ssize_t PyMapping_Length(PyObject *o);
# 1302 "/usr/include/python2.6/abstract.h"
     int PyMapping_HasKeyString(PyObject *o, char *key);
# 1312 "/usr/include/python2.6/abstract.h"
     int PyMapping_HasKey(PyObject *o, PyObject *key);
# 1355 "/usr/include/python2.6/abstract.h"
     PyObject * PyMapping_GetItemString(PyObject *o, char *key);







     int PyMapping_SetItemString(PyObject *o, char *key,
                                            PyObject *value);
# 1373 "/usr/include/python2.6/abstract.h"
int PyObject_IsInstance(PyObject *object, PyObject *typeorclass);


int PyObject_IsSubclass(PyObject *object, PyObject *typeorclass);



int _PyObject_RealIsInstance(PyObject *inst, PyObject *cls);

int _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls);



}
# 133 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/compile.h" 1




# 1 "/usr/include/python2.6/code.h" 1





extern "C" {



typedef struct {
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
    int co_argcount;
    int co_nlocals;
    int co_stacksize;
    int co_flags;
    PyObject *co_code;
    PyObject *co_consts;
    PyObject *co_names;
    PyObject *co_varnames;
    PyObject *co_freevars;
    PyObject *co_cellvars;

    PyObject *co_filename;
    PyObject *co_name;
    int co_firstlineno;
    PyObject *co_lnotab;
    void *co_zombieframe;
} PyCodeObject;
# 63 "/usr/include/python2.6/code.h"
extern PyTypeObject PyCode_Type;





PyCodeObject * PyCode_New(
 int, int, int, int, PyObject *, PyObject *, PyObject *, PyObject *,
 PyObject *, PyObject *, PyObject *, PyObject *, int, PyObject *);

int PyCode_Addr2Line(PyCodeObject *, int);






typedef struct _addr_pair {
        int ap_lower;
        int ap_upper;
} PyAddrPair;
# 92 "/usr/include/python2.6/code.h"
int PyCode_CheckLineNumber(PyCodeObject* co,
                                       int lasti, PyAddrPair *bounds);

PyObject* PyCode_Optimize(PyObject *code, PyObject* consts,
                                      PyObject *names, PyObject *lineno_obj);


}
# 6 "/usr/include/python2.6/compile.h" 2


extern "C" {



struct _node;
PyCodeObject * PyNode_Compile(struct _node *, const char *);



typedef struct {
    int ff_features;
    int ff_lineno;
} PyFutureFeatures;
# 31 "/usr/include/python2.6/compile.h"
struct _mod;
PyCodeObject * PyAST_Compile(struct _mod *, const char *,
     PyCompilerFlags *, PyArena *);
PyFutureFeatures * PyFuture_FromAST(struct _mod *, const char *);





}
# 135 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/eval.h" 1






extern "C" {


PyObject * PyEval_EvalCode(PyCodeObject *, PyObject *, PyObject *);

PyObject * PyEval_EvalCodeEx(PyCodeObject *co,
     PyObject *globals,
     PyObject *locals,
     PyObject **args, int argc,
     PyObject **kwds, int kwdc,
     PyObject **defs, int defc,
     PyObject *closure);

PyObject * _PyEval_CallTracing(PyObject *func, PyObject *args);


}
# 136 "/usr/include/python2.6/Python.h" 2

# 1 "/usr/include/python2.6/pystrtod.h" 1




extern "C" {



double PyOS_ascii_strtod(const char *str, char **ptr);
double PyOS_ascii_atof(const char *str);
char * PyOS_ascii_formatd(char *buffer, size_t buf_len, const char *format, double d);



}
# 138 "/usr/include/python2.6/Python.h" 2
# 1 "/usr/include/python2.6/pystrcmp.h" 1




extern "C" {


int PyOS_mystrnicmp(const char *, const char *, Py_ssize_t);
int PyOS_mystricmp(const char *, const char *);
# 20 "/usr/include/python2.6/pystrcmp.h"
}
# 139 "/usr/include/python2.6/Python.h" 2


PyObject* _Py_Mangle(PyObject *p, PyObject *name);
# 158 "/usr/include/python2.6/Python.h"
# 1 "/usr/include/python2.6/pyfpe.h" 1



extern "C" {
# 129 "/usr/include/python2.6/pyfpe.h"
# 1 "/usr/include/signal.h" 1 3 4
# 31 "/usr/include/signal.h" 3 4
extern "C" {

# 1 "/usr/include/bits/sigset.h" 1 3 4
# 104 "/usr/include/bits/sigset.h" 3 4
extern int __sigismember (__const __sigset_t *, int);
extern int __sigaddset (__sigset_t *, int);
extern int __sigdelset (__sigset_t *, int);
# 118 "/usr/include/bits/sigset.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int __sigismember (__const __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return (__set->__val[__word] & __mask) ? 1 : 0; }
extern __inline __attribute__ ((__gnu_inline__)) int __sigaddset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] |= __mask), 0); }
extern __inline __attribute__ ((__gnu_inline__)) int __sigdelset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] &= ~__mask), 0); }
# 34 "/usr/include/signal.h" 2 3 4







typedef __sig_atomic_t sig_atomic_t;

# 58 "/usr/include/signal.h" 3 4
# 1 "/usr/include/bits/signum.h" 1 3 4
# 59 "/usr/include/signal.h" 2 3 4
# 79 "/usr/include/signal.h" 3 4
# 1 "/usr/include/bits/siginfo.h" 1 3 4
# 25 "/usr/include/bits/siginfo.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 26 "/usr/include/bits/siginfo.h" 2 3 4







typedef union sigval
  {
    int sival_int;
    void *sival_ptr;
  } sigval_t;
# 51 "/usr/include/bits/siginfo.h" 3 4
typedef struct siginfo
  {
    int si_signo;
    int si_errno;

    int si_code;

    union
      {
 int _pad[((128 / sizeof (int)) - 4)];


 struct
   {
     __pid_t si_pid;
     __uid_t si_uid;
   } _kill;


 struct
   {
     int si_tid;
     int si_overrun;
     sigval_t si_sigval;
   } _timer;


 struct
   {
     __pid_t si_pid;
     __uid_t si_uid;
     sigval_t si_sigval;
   } _rt;


 struct
   {
     __pid_t si_pid;
     __uid_t si_uid;
     int si_status;
     __clock_t si_utime;
     __clock_t si_stime;
   } _sigchld;


 struct
   {
     void *si_addr;
   } _sigfault;


 struct
   {
     long int si_band;
     int si_fd;
   } _sigpoll;
      } _sifields;
  } siginfo_t;
# 129 "/usr/include/bits/siginfo.h" 3 4
enum
{
  SI_ASYNCNL = -60,

  SI_TKILL = -6,

  SI_SIGIO,

  SI_ASYNCIO,

  SI_MESGQ,

  SI_TIMER,

  SI_QUEUE,

  SI_USER,

  SI_KERNEL = 0x80

};



enum
{
  ILL_ILLOPC = 1,

  ILL_ILLOPN,

  ILL_ILLADR,

  ILL_ILLTRP,

  ILL_PRVOPC,

  ILL_PRVREG,

  ILL_COPROC,

  ILL_BADSTK

};


enum
{
  FPE_INTDIV = 1,

  FPE_INTOVF,

  FPE_FLTDIV,

  FPE_FLTOVF,

  FPE_FLTUND,

  FPE_FLTRES,

  FPE_FLTINV,

  FPE_FLTSUB

};


enum
{
  SEGV_MAPERR = 1,

  SEGV_ACCERR

};


enum
{
  BUS_ADRALN = 1,

  BUS_ADRERR,

  BUS_OBJERR

};


enum
{
  TRAP_BRKPT = 1,

  TRAP_TRACE

};


enum
{
  CLD_EXITED = 1,

  CLD_KILLED,

  CLD_DUMPED,

  CLD_TRAPPED,

  CLD_STOPPED,

  CLD_CONTINUED

};


enum
{
  POLL_IN = 1,

  POLL_OUT,

  POLL_MSG,

  POLL_ERR,

  POLL_PRI,

  POLL_HUP

};
# 273 "/usr/include/bits/siginfo.h" 3 4
typedef struct sigevent
  {
    sigval_t sigev_value;
    int sigev_signo;
    int sigev_notify;

    union
      {
 int _pad[((64 / sizeof (int)) - 4)];



 __pid_t _tid;

 struct
   {
     void (*_function) (sigval_t);
     void *_attribute;
   } _sigev_thread;
      } _sigev_un;
  } sigevent_t;






enum
{
  SIGEV_SIGNAL = 0,

  SIGEV_NONE,

  SIGEV_THREAD,


  SIGEV_THREAD_ID = 4

};
# 80 "/usr/include/signal.h" 2 3 4




typedef void (*__sighandler_t) (int);




extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
     throw ();

extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
     throw ();







extern __sighandler_t signal (int __sig, __sighandler_t __handler)
     throw ();
# 113 "/usr/include/signal.h" 3 4





extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
     throw ();






extern int kill (__pid_t __pid, int __sig) throw ();






extern int killpg (__pid_t __pgrp, int __sig) throw ();




extern int raise (int __sig) throw ();




extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
     throw ();
extern int gsignal (int __sig) throw ();




extern void psignal (int __sig, __const char *__s);




extern void psiginfo (__const siginfo_t *__pinfo, __const char *__s);
# 168 "/usr/include/signal.h" 3 4
extern int __sigpause (int __sig_or_mask, int __is_sig);
# 177 "/usr/include/signal.h" 3 4
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
# 196 "/usr/include/signal.h" 3 4
extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));


extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));


extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
# 211 "/usr/include/signal.h" 3 4
typedef __sighandler_t sighandler_t;




typedef __sighandler_t sig_t;





extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));


extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));


extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));


extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));


extern int sigismember (__const sigset_t *__set, int __signo)
     throw () __attribute__ ((__nonnull__ (1)));



extern int sigisemptyset (__const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));


extern int sigandset (sigset_t *__set, __const sigset_t *__left,
        __const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));


extern int sigorset (sigset_t *__set, __const sigset_t *__left,
       __const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));




# 1 "/usr/include/bits/sigaction.h" 1 3 4
# 25 "/usr/include/bits/sigaction.h" 3 4
struct sigaction
  {


    union
      {

 __sighandler_t sa_handler;

 void (*sa_sigaction) (int, siginfo_t *, void *);
      }
    __sigaction_handler;







    __sigset_t sa_mask;


    int sa_flags;


    void (*sa_restorer) (void);
  };
# 253 "/usr/include/signal.h" 2 3 4


extern int sigprocmask (int __how, __const sigset_t *__restrict __set,
   sigset_t *__restrict __oset) throw ();






extern int sigsuspend (__const sigset_t *__set) __attribute__ ((__nonnull__ (1)));


extern int sigaction (int __sig, __const struct sigaction *__restrict __act,
        struct sigaction *__restrict __oact) throw ();


extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));






extern int sigwait (__const sigset_t *__restrict __set, int *__restrict __sig)
     __attribute__ ((__nonnull__ (1, 2)));






extern int sigwaitinfo (__const sigset_t *__restrict __set,
   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));






extern int sigtimedwait (__const sigset_t *__restrict __set,
    siginfo_t *__restrict __info,
    __const struct timespec *__restrict __timeout)
     __attribute__ ((__nonnull__ (1)));



extern int sigqueue (__pid_t __pid, int __sig, __const union sigval __val)
     throw ();
# 310 "/usr/include/signal.h" 3 4
extern __const char *__const _sys_siglist[65];
extern __const char *__const sys_siglist[65];


struct sigvec
  {
    __sighandler_t sv_handler;
    int sv_mask;

    int sv_flags;

  };
# 334 "/usr/include/signal.h" 3 4
extern int sigvec (int __sig, __const struct sigvec *__vec,
     struct sigvec *__ovec) throw ();



# 1 "/usr/include/bits/sigcontext.h" 1 3 4
# 26 "/usr/include/bits/sigcontext.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 27 "/usr/include/bits/sigcontext.h" 2 3 4

struct _fpreg
{
  unsigned short significand[4];
  unsigned short exponent;
};

struct _fpxreg
{
  unsigned short significand[4];
  unsigned short exponent;
  unsigned short padding[3];
};

struct _xmmreg
{
  __uint32_t element[4];
};
# 109 "/usr/include/bits/sigcontext.h" 3 4
struct _fpstate
{

  __uint16_t cwd;
  __uint16_t swd;
  __uint16_t ftw;
  __uint16_t fop;
  __uint64_t rip;
  __uint64_t rdp;
  __uint32_t mxcsr;
  __uint32_t mxcr_mask;
  struct _fpxreg _st[8];
  struct _xmmreg _xmm[16];
  __uint32_t padding[24];
};

struct sigcontext
{
  unsigned long r8;
  unsigned long r9;
  unsigned long r10;
  unsigned long r11;
  unsigned long r12;
  unsigned long r13;
  unsigned long r14;
  unsigned long r15;
  unsigned long rdi;
  unsigned long rsi;
  unsigned long rbp;
  unsigned long rbx;
  unsigned long rdx;
  unsigned long rax;
  unsigned long rcx;
  unsigned long rsp;
  unsigned long rip;
  unsigned long eflags;
  unsigned short cs;
  unsigned short gs;
  unsigned short fs;
  unsigned short __pad0;
  unsigned long err;
  unsigned long trapno;
  unsigned long oldmask;
  unsigned long cr2;
  struct _fpstate * fpstate;
  unsigned long __reserved1 [8];
};
# 340 "/usr/include/signal.h" 2 3 4


extern int sigreturn (struct sigcontext *__scp) throw ();






# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 350 "/usr/include/signal.h" 2 3 4




extern int siginterrupt (int __sig, int __interrupt) throw ();

# 1 "/usr/include/bits/sigstack.h" 1 3 4
# 26 "/usr/include/bits/sigstack.h" 3 4
struct sigstack
  {
    void *ss_sp;
    int ss_onstack;
  };



enum
{
  SS_ONSTACK = 1,

  SS_DISABLE

};
# 50 "/usr/include/bits/sigstack.h" 3 4
typedef struct sigaltstack
  {
    void *ss_sp;
    int ss_flags;
    size_t ss_size;
  } stack_t;
# 357 "/usr/include/signal.h" 2 3 4


# 1 "/usr/include/sys/ucontext.h" 1 3 4
# 24 "/usr/include/sys/ucontext.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 25 "/usr/include/sys/ucontext.h" 2 3 4
# 33 "/usr/include/sys/ucontext.h" 3 4
typedef long int greg_t;





typedef greg_t gregset_t[23];



enum
{
  REG_R8 = 0,

  REG_R9,

  REG_R10,

  REG_R11,

  REG_R12,

  REG_R13,

  REG_R14,

  REG_R15,

  REG_RDI,

  REG_RSI,

  REG_RBP,

  REG_RBX,

  REG_RDX,

  REG_RAX,

  REG_RCX,

  REG_RSP,

  REG_RIP,

  REG_EFL,

  REG_CSGSFS,

  REG_ERR,

  REG_TRAPNO,

  REG_OLDMASK,

  REG_CR2

};


struct _libc_fpxreg
{
  unsigned short int significand[4];
  unsigned short int exponent;
  unsigned short int padding[3];
};

struct _libc_xmmreg
{
  __uint32_t element[4];
};

struct _libc_fpstate
{

  __uint16_t cwd;
  __uint16_t swd;
  __uint16_t ftw;
  __uint16_t fop;
  __uint64_t rip;
  __uint64_t rdp;
  __uint32_t mxcsr;
  __uint32_t mxcr_mask;
  struct _libc_fpxreg _st[8];
  struct _libc_xmmreg _xmm[16];
  __uint32_t padding[24];
};


typedef struct _libc_fpstate *fpregset_t;


typedef struct
  {
    gregset_t gregs;

    fpregset_t fpregs;
    unsigned long __reserved1 [8];
} mcontext_t;


typedef struct ucontext
  {
    unsigned long int uc_flags;
    struct ucontext *uc_link;
    stack_t uc_stack;
    mcontext_t uc_mcontext;
    __sigset_t uc_sigmask;
    struct _libc_fpstate __fpregs_mem;
  } ucontext_t;
# 360 "/usr/include/signal.h" 2 3 4





extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
     throw () __attribute__ ((__deprecated__));



extern int sigaltstack (__const struct sigaltstack *__restrict __ss,
   struct sigaltstack *__restrict __oss) throw ();







extern int sighold (int __sig) throw ();


extern int sigrelse (int __sig) throw ();


extern int sigignore (int __sig) throw ();


extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();






# 1 "/usr/include/bits/sigthread.h" 1 3 4
# 31 "/usr/include/bits/sigthread.h" 3 4
extern int pthread_sigmask (int __how,
       __const __sigset_t *__restrict __newmask,
       __sigset_t *__restrict __oldmask)throw ();


extern int pthread_kill (pthread_t __threadid, int __signo) throw ();



extern int pthread_sigqueue (pthread_t __threadid, int __signo,
        const union sigval __value) throw ();
# 396 "/usr/include/signal.h" 2 3 4






extern int __libc_current_sigrtmin (void) throw ();

extern int __libc_current_sigrtmax (void) throw ();



}
# 130 "/usr/include/python2.6/pyfpe.h" 2
# 1 "/usr/include/setjmp.h" 1 3 4
# 28 "/usr/include/setjmp.h" 3 4
extern "C" {


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 32 "/usr/include/setjmp.h" 2 3 4



struct __jmp_buf_tag
  {




    __jmp_buf __jmpbuf;
    int __mask_was_saved;
    __sigset_t __saved_mask;
  };




typedef struct __jmp_buf_tag jmp_buf[1];



extern int setjmp (jmp_buf __env) throw ();






extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) throw ();




extern int _setjmp (struct __jmp_buf_tag __env[1]) throw ();
# 78 "/usr/include/setjmp.h" 3 4




extern void longjmp (struct __jmp_buf_tag __env[1], int __val)
     throw () __attribute__ ((__noreturn__));







extern void _longjmp (struct __jmp_buf_tag __env[1], int __val)
     throw () __attribute__ ((__noreturn__));







typedef struct __jmp_buf_tag sigjmp_buf[1];
# 110 "/usr/include/setjmp.h" 3 4
extern void siglongjmp (sigjmp_buf __env, int __val)
     throw () __attribute__ ((__noreturn__));





# 1 "/usr/include/bits/setjmp2.h" 1 3 4
# 26 "/usr/include/bits/setjmp2.h" 3 4
extern void longjmp (struct __jmp_buf_tag __env[1], int __val) throw () __asm__ ("" "__longjmp_chk")

                      __attribute__ ((__noreturn__));
extern void _longjmp (struct __jmp_buf_tag __env[1], int __val) throw () __asm__ ("" "__longjmp_chk")

                      __attribute__ ((__noreturn__));
extern void siglongjmp (struct __jmp_buf_tag __env[1], int __val) throw () __asm__ ("" "__longjmp_chk")

                      __attribute__ ((__noreturn__));
# 118 "/usr/include/setjmp.h" 2 3 4


}
# 131 "/usr/include/python2.6/pyfpe.h" 2

extern jmp_buf PyFPE_jbuf;
extern int PyFPE_counter;
extern double PyFPE_dummy(void *);
# 174 "/usr/include/python2.6/pyfpe.h"
}
# 159 "/usr/include/python2.6/Python.h" 2
# 143 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp" 2
# 14 "/usr/include/boost-1_42/boost/python/detail/prefix.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/config.hpp" 1
# 15 "/usr/include/boost-1_42/boost/python/detail/config.hpp"
# 1 "/usr/include/boost-1_42/boost/config.hpp" 1
# 26 "/usr/include/boost-1_42/boost/config.hpp"
# 1 "/usr/include/boost-1_42/boost/config/user.hpp" 1
# 27 "/usr/include/boost-1_42/boost/config.hpp" 2




# 1 "/usr/include/boost-1_42/boost/config/select_compiler_config.hpp" 1
# 32 "/usr/include/boost-1_42/boost/config.hpp" 2



# 1 "/usr/include/boost-1_42/boost/config/compiler/gcc.hpp" 1
# 36 "/usr/include/boost-1_42/boost/config.hpp" 2




# 1 "/usr/include/boost-1_42/boost/config/select_stdlib_config.hpp" 1
# 17 "/usr/include/boost-1_42/boost/config/select_stdlib_config.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 18 "/usr/include/boost-1_42/boost/config/select_stdlib_config.hpp" 2
# 33 "/usr/include/boost-1_42/boost/config/select_stdlib_config.hpp"
# 1 "/usr/include/boost-1_42/boost/config/no_tr1/utility.hpp" 1
# 21 "/usr/include/boost-1_42/boost/config/no_tr1/utility.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/utility" 1 3
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/utility" 3
       
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/utility" 3
# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/utility" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 1 3
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  namespace rel_ops
  {
# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator!=(const _Tp& __x, const _Tp& __y)
      { return !(__x == __y); }
# 96 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>(const _Tp& __x, const _Tp& __y)
      { return __y < __x; }
# 109 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator<=(const _Tp& __x, const _Tp& __y)
      { return !(__y < __x); }
# 122 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>=(const _Tp& __x, const _Tp& __y)
      { return !(__x < __y); }

  }

}
# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/utility" 2 3
# 22 "/usr/include/boost-1_42/boost/config/no_tr1/utility.hpp" 2
# 34 "/usr/include/boost-1_42/boost/config/select_stdlib_config.hpp" 2
# 41 "/usr/include/boost-1_42/boost/config.hpp" 2



# 1 "/usr/include/boost-1_42/boost/config/stdlib/libstdcpp3.hpp" 1
# 45 "/usr/include/boost-1_42/boost/config.hpp" 2




# 1 "/usr/include/boost-1_42/boost/config/select_platform_config.hpp" 1
# 50 "/usr/include/boost-1_42/boost/config.hpp" 2



# 1 "/usr/include/boost-1_42/boost/config/platform/linux.hpp" 1
# 14 "/usr/include/boost-1_42/boost/config/platform/linux.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 2 3
# 100 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  using ::div_t;
  using ::ldiv_t;

  using ::abort;
  using ::abs;
  using ::atexit;
  using ::atof;
  using ::atoi;
  using ::atol;
  using ::bsearch;
  using ::calloc;
  using ::div;
  using ::exit;
  using ::free;
  using ::getenv;
  using ::labs;
  using ::ldiv;
  using ::malloc;

  using ::mblen;
  using ::mbstowcs;
  using ::mbtowc;

  using ::qsort;
  using ::rand;
  using ::realloc;
  using ::srand;
  using ::strtod;
  using ::strtol;
  using ::strtoul;
  using ::system;

  using ::wcstombs;
  using ::wctomb;


  inline long
  abs(long __i) { return labs(__i); }

  inline ldiv_t
  div(long __i, long __j) { return ldiv(__i, __j); }

}
# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {


  using ::lldiv_t;





  using ::_Exit;


  inline long long
  abs(long long __x) { return __x >= 0 ? __x : -__x; }


  using ::llabs;

  inline lldiv_t
  div(long long __n, long long __d)
  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }

  using ::lldiv;
# 190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
  using ::atoll;
  using ::strtoll;
  using ::strtoull;

  using ::strtof;
  using ::strtold;

}

namespace std __attribute__ ((__visibility__ ("default"))) {


  using ::__gnu_cxx::lldiv_t;

  using ::__gnu_cxx::_Exit;
  using ::__gnu_cxx::abs;

  using ::__gnu_cxx::llabs;
  using ::__gnu_cxx::div;
  using ::__gnu_cxx::lldiv;

  using ::__gnu_cxx::atoll;
  using ::__gnu_cxx::strtof;
  using ::__gnu_cxx::strtoll;
  using ::__gnu_cxx::strtoull;
  using ::__gnu_cxx::strtold;

}
# 15 "/usr/include/boost-1_42/boost/config/platform/linux.hpp" 2
# 70 "/usr/include/boost-1_42/boost/config/platform/linux.hpp"
# 1 "/usr/include/boost-1_42/boost/config/posix_features.hpp" 1
# 71 "/usr/include/boost-1_42/boost/config/platform/linux.hpp" 2
# 54 "/usr/include/boost-1_42/boost/config.hpp" 2



# 1 "/usr/include/boost-1_42/boost/config/suffix.hpp" 1
# 468 "/usr/include/boost-1_42/boost/config/suffix.hpp"
namespace boost{

   __extension__ typedef long long long_long_type;
   __extension__ typedef unsigned long long ulong_long_type;




}
# 58 "/usr/include/boost-1_42/boost/config.hpp" 2
# 16 "/usr/include/boost-1_42/boost/python/detail/config.hpp" 2
# 1 "/usr/include/boost-1_42/boost/detail/workaround.hpp" 1
# 17 "/usr/include/boost-1_42/boost/python/detail/config.hpp" 2
# 134 "/usr/include/boost-1_42/boost/python/detail/config.hpp"
# 1 "/usr/include/boost-1_42/boost/config/auto_link.hpp" 1
# 135 "/usr/include/boost-1_42/boost/python/detail/config.hpp" 2
# 15 "/usr/include/boost-1_42/boost/python/detail/prefix.hpp" 2
# 9 "/usr/include/boost-1_42/boost/python/args.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/args_fwd.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/args_fwd.hpp"
# 1 "/usr/include/boost-1_42/boost/python/handle.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/handle.hpp"
# 1 "/usr/include/boost-1_42/boost/python/cast.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/cast.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/same_traits.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/same_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp" 1
# 24 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/config.hpp" 1
# 25 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp" 2






# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 10 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/int.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/int.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/int_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/int_fwd.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/adl_barrier.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/adl_barrier.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/msvc.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/intel.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/gcc.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/workaround.hpp" 1
# 21 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp" 2
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/adl_barrier.hpp" 2
# 33 "/usr/include/boost-1_42/boost/mpl/aux_/adl_barrier.hpp"
namespace mpl_ { namespace aux {} }
namespace boost { namespace mpl { using namespace mpl_;
namespace aux { using namespace mpl_::aux; }
}}
# 18 "/usr/include/boost-1_42/boost/mpl/int_fwd.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/nttp_decl.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/nttp_decl.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/nttp.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/nttp_decl.hpp" 2
# 19 "/usr/include/boost-1_42/boost/mpl/int_fwd.hpp" 2

namespace mpl_ {

template< int N > struct int_;

}
namespace boost { namespace mpl { using ::mpl_::int_; } }
# 18 "/usr/include/boost-1_42/boost/mpl/int.hpp" 2


# 1 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 1
# 16 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/integral_c_tag.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/integral_c_tag.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/static_constant.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/integral_c_tag.hpp" 2

namespace mpl_ {
struct integral_c_tag { static const int value = 0; };
}
namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/static_cast.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 2




# 1 "/usr/include/boost-1_42/boost/preprocessor/cat.hpp" 1
# 17 "/usr/include/boost-1_42/boost/preprocessor/cat.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/config/config.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/cat.hpp" 2
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 2
# 40 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
namespace mpl_ {

template< int N >
struct int_
{
    static const int value = N;





    typedef int_ type;

    typedef int value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
    typedef mpl_::int_< static_cast<int>((value + 1)) > next;
    typedef mpl_::int_< static_cast<int>((value - 1)) > prior;






    operator int() const { return static_cast<int>(this->value); }
};


template< int N >
int const mpl_::int_< N >::value;


}
# 21 "/usr/include/boost-1_42/boost/mpl/int.hpp" 2
# 11 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/template_arity_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/template_arity_fwd.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename F > struct template_arity;

}}}
# 12 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/preprocessor.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp" 2
# 45 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/comma_if.hpp" 1
# 15 "/usr/include/boost-1_42/boost/preprocessor/comma_if.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma_if.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma_if.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/control/if.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/control/if.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/control/iif.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/control/if.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/logical/bool.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/control/if.hpp" 2
# 19 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma_if.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/facilities/empty.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma_if.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma.hpp" 1
# 21 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma_if.hpp" 2
# 16 "/usr/include/boost-1_42/boost/preprocessor/comma_if.hpp" 2
# 46 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/repeat.hpp" 1
# 15 "/usr/include/boost-1_42/boost/preprocessor/repeat.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/debug/error.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/eat.hpp" 1
# 22 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat.hpp" 2
# 16 "/usr/include/boost-1_42/boost/preprocessor/repeat.hpp" 2
# 47 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/inc.hpp" 1
# 15 "/usr/include/boost-1_42/boost/preprocessor/inc.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/inc.hpp" 1
# 16 "/usr/include/boost-1_42/boost/preprocessor/inc.hpp" 2
# 48 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp" 2
# 13 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/lambda.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/config/lambda.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/ttp.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/config/lambda.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/ctps.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/config/lambda.hpp" 2
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/overload_resolution.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 2
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/integral_constant.hpp" 1
# 10 "/usr/include/boost-1_42/boost/type_traits/integral_constant.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/bool.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/bool.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/bool_fwd.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/bool_fwd.hpp"
namespace mpl_ {

template< bool C_ > struct bool_;


typedef bool_<true> true_;
typedef bool_<false> false_;

}

namespace boost { namespace mpl { using ::mpl_::bool_; } }
namespace boost { namespace mpl { using ::mpl_::true_; } }
namespace boost { namespace mpl { using ::mpl_::false_; } }
# 18 "/usr/include/boost-1_42/boost/mpl/bool.hpp" 2



namespace mpl_ {

template< bool C_ > struct bool_
{
    static const bool value = C_;
    typedef integral_c_tag tag;
    typedef bool_ type;
    typedef bool value_type;
    operator bool() const { return this->value; }
};


template< bool C_ >
bool const bool_<C_>::value;


}
# 11 "/usr/include/boost-1_42/boost/type_traits/integral_constant.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/integral_c.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/integral_c.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/integral_c_fwd.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/integral_c_fwd.hpp"
namespace mpl_ {





template< typename T, T N > struct integral_c;


}
namespace boost { namespace mpl { using ::mpl_::integral_c; } }
# 18 "/usr/include/boost-1_42/boost/mpl/integral_c.hpp" 2
# 32 "/usr/include/boost-1_42/boost/mpl/integral_c.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 1
# 40 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
namespace mpl_ {

template< typename T, T N >
struct integral_c
{
    static const T value = N;





    typedef integral_c type;

    typedef T value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
    typedef integral_c< T, static_cast<T>((value + 1)) > next;
    typedef integral_c< T, static_cast<T>((value - 1)) > prior;






    operator T() const { return static_cast<T>(this->value); }
};


template< typename T, T N >
T const integral_c< T, N >::value;


}
# 33 "/usr/include/boost-1_42/boost/mpl/integral_c.hpp" 2




namespace mpl_ {

template< bool C >
struct integral_c<bool, C>
{
    static const bool value = C;
    typedef integral_c_tag tag;
    typedef integral_c type;
    typedef bool value_type;
    operator bool() const { return this->value; }
};
}
# 12 "/usr/include/boost-1_42/boost/type_traits/integral_constant.hpp" 2

namespace boost{




template <class T, T val>

struct integral_constant : public mpl::integral_c<T, val>
{
   typedef integral_constant<T,val> type;
};

template<> struct integral_constant<bool,true> : public mpl::true_
{







   typedef integral_constant<bool,true> type;
};
template<> struct integral_constant<bool,false> : public mpl::false_
{







   typedef integral_constant<bool,false> type;
};

typedef integral_constant<bool,true> true_type;
typedef integral_constant<bool,false> false_type;

}
# 16 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/aux_/lambda_support.hpp" 1
# 18 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 32 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp" 2

namespace boost {



template< typename T, typename U > struct is_same : ::boost::integral_constant<bool,false> { };
template< typename T > struct is_same< T,T > : ::boost::integral_constant<bool,true> { };
# 98 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 101 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp" 2
# 14 "/usr/include/boost-1_42/boost/type_traits/same_traits.hpp" 2
# 11 "/usr/include/boost-1_42/boost/python/cast.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/add_const.hpp" 1
# 16 "/usr/include/boost-1_42/boost/type_traits/add_const.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 17 "/usr/include/boost-1_42/boost/type_traits/add_const.hpp" 2

namespace boost {
# 33 "/usr/include/boost-1_42/boost/type_traits/add_const.hpp"
template< typename T > struct add_const { typedef T const type; };






template< typename T > struct add_const<T&> { typedef T& type; };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 46 "/usr/include/boost-1_42/boost/type_traits/add_const.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/add_volatile.hpp" 1
# 16 "/usr/include/boost-1_42/boost/type_traits/add_volatile.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 17 "/usr/include/boost-1_42/boost/type_traits/add_volatile.hpp" 2

namespace boost {
# 33 "/usr/include/boost-1_42/boost/type_traits/add_volatile.hpp"
template< typename T > struct add_volatile { typedef T volatile type; };






template< typename T > struct add_volatile<T&> { typedef T& type; };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 46 "/usr/include/boost-1_42/boost/type_traits/add_volatile.hpp" 2
# 17 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/add_cv.hpp" 1
# 17 "/usr/include/boost-1_42/boost/type_traits/add_cv.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 18 "/usr/include/boost-1_42/boost/type_traits/add_cv.hpp" 2

namespace boost {
# 34 "/usr/include/boost-1_42/boost/type_traits/add_cv.hpp"
template< typename T > struct add_cv { typedef T const volatile type; };






template< typename T > struct add_cv<T&> { typedef T& type; };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 47 "/usr/include/boost-1_42/boost/type_traits/add_cv.hpp" 2
# 18 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp" 1
# 28 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/cv_traits_impl.hpp" 1
# 23 "/usr/include/boost-1_42/boost/type_traits/detail/cv_traits_impl.hpp"
namespace boost {
namespace detail {







template <typename T> struct cv_traits_imp {};

template <typename T>
struct cv_traits_imp<T*>
{
    static const bool is_const = false;
    static const bool is_volatile = false;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<const T*>
{
    static const bool is_const = true;
    static const bool is_volatile = false;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<volatile T*>
{
    static const bool is_const = false;
    static const bool is_volatile = true;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<const volatile T*>
{
    static const bool is_const = true;
    static const bool is_volatile = true;
    typedef T unqualified_type;
};
# 92 "/usr/include/boost-1_42/boost/type_traits/detail/cv_traits_impl.hpp"
}
}
# 29 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp" 2

# 1 "/usr/include/boost-1_42/boost/type_traits/is_reference.hpp" 1
# 32 "/usr/include/boost-1_42/boost/type_traits/is_reference.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 33 "/usr/include/boost-1_42/boost/type_traits/is_reference.hpp" 2

namespace boost {





template< typename T > struct is_reference : ::boost::integral_constant<bool,false> { };
template< typename T > struct is_reference< T& > : ::boost::integral_constant<bool,true> { };
# 113 "/usr/include/boost-1_42/boost/type_traits/is_reference.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 116 "/usr/include/boost-1_42/boost/type_traits/is_reference.hpp" 2
# 31 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp" 2
# 43 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 44 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp" 2

namespace boost {
# 57 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp"
   template< typename T > struct is_const : ::boost::integral_constant<bool,::boost::detail::cv_traits_imp<T*>::is_const> { };

template< typename T > struct is_const< T& > : ::boost::integral_constant<bool,false> { };
# 141 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 144 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp" 2
# 19 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp" 1
# 40 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 41 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp" 2

namespace boost {
# 52 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp"
   template< typename T > struct is_volatile : ::boost::integral_constant<bool,::boost::detail::cv_traits_imp<T*>::is_volatile> { };

template< typename T > struct is_volatile< T& > : ::boost::integral_constant<bool,false> { };
# 129 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 132 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp" 2
# 20 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/broken_compiler_spec.hpp" 1
# 95 "/usr/include/boost-1_42/boost/type_traits/broken_compiler_spec.hpp"















# 16 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp" 2




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 21 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp" 2






# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 28 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp" 2

namespace boost {



namespace detail {

template <typename T, bool is_vol>
struct remove_const_helper
{
    typedef T type;
};

template <typename T>
struct remove_const_helper<T, true>
{
    typedef T volatile type;
};


template <typename T>
struct remove_const_impl
{
    typedef typename remove_const_helper<
          typename cv_traits_imp<T*>::unqualified_type
        , ::boost::is_volatile<T>::value
        >::type type;
};

}



template< typename T > struct remove_const { typedef typename boost::detail::remove_const_impl<T>::type type; };
template< typename T > struct remove_const<T&> { typedef T& type; };

template< typename T, std::size_t N > struct remove_const<T const[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_const<T const volatile[N]> { typedef T volatile type[N]; };
# 74 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 77 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp" 2
# 21 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp" 1
# 20 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 21 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp" 2






# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 28 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp" 2

namespace boost {



namespace detail {

template <typename T, bool is_const>
struct remove_volatile_helper
{
    typedef T type;
};

template <typename T>
struct remove_volatile_helper<T,true>
{
    typedef T const type;
};

template <typename T>
struct remove_volatile_impl
{
    typedef typename remove_volatile_helper<
          typename cv_traits_imp<T*>::unqualified_type
        , ::boost::is_const<T>::value
        >::type type;
};

}



template< typename T > struct remove_volatile { typedef typename boost::detail::remove_volatile_impl<T>::type type; };
template< typename T > struct remove_volatile<T&> { typedef T& type; };

template< typename T, std::size_t N > struct remove_volatile<T volatile[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_volatile<T const volatile[N]> { typedef T const type[N]; };
# 73 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 76 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp" 1
# 19 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp" 2






# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 27 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp" 2

namespace boost {




template< typename T > struct remove_cv { typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type; };
template< typename T > struct remove_cv<T&> { typedef T& type; };

template< typename T, std::size_t N > struct remove_cv<T const[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { typedef T type[N]; };
# 57 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 60 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp" 2
# 23 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
# 12 "/usr/include/boost-1_42/boost/python/cast.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type.hpp" 1
# 9 "/usr/include/boost-1_42/boost/type.hpp"
namespace boost {



  template <class T>
  struct type {};

}
# 13 "/usr/include/boost-1_42/boost/python/cast.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/base_type_traits.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/base_type_traits.hpp"
namespace boost { namespace python {

namespace detail
{
  struct unspecialized {};
}



template <class T> struct base_type_traits
  : detail::unspecialized
{};

template <>
struct base_type_traits<PyObject>
{
    typedef PyObject type;
};

template <>
struct base_type_traits<PyTypeObject>
{
    typedef PyObject type;
};

template <>
struct base_type_traits<PyMethodObject>
{
    typedef PyObject type;
};

}}
# 14 "/usr/include/boost-1_42/boost/python/cast.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/convertible.hpp" 1
# 15 "/usr/include/boost-1_42/boost/python/detail/convertible.hpp"
namespace boost { namespace python { namespace detail {

typedef char* yes_convertible;
typedef int* no_convertible;

template <class Target>
struct convertible
{

    static inline no_convertible check(...) { return 0; }
    static inline yes_convertible check(Target) { return 0; }
# 34 "/usr/include/boost-1_42/boost/python/detail/convertible.hpp"
};

}}}
# 15 "/usr/include/boost-1_42/boost/python/cast.hpp" 2

namespace boost { namespace python {

namespace detail
{
  template <class Source, class Target> inline Target* upcast_impl(Source*, Target*);

  template <class Source, class Target>
  inline Target* upcast(Source* p, yes_convertible, no_convertible, Target*)
  {
      return p;
  }

  template <class Source, class Target>
  inline Target* upcast(Source* p, no_convertible, no_convertible, Target*)
  {
      typedef typename base_type_traits<Source>::type base;

      return detail::upcast_impl((base*)p, (Target*)0);
  }

  template <bool is_same = true>
  struct upcaster
  {
      template <class T>
      static inline T* execute(T* x, T*) { return x; }
  };

  template <>
  struct upcaster<false>
  {
      template <class Source, class Target>
      static inline Target* execute(Source* x, Target*)
      {
          return detail::upcast(
              x, detail::convertible<Target*>::check(x)
              , detail::convertible<Source*>::check((Target*)0)
              , (Target*)0);
      }
  };


  template <class Target, class Source>
  inline Target* downcast(Source* p, yes_convertible)
  {
      return static_cast<Target*>(p);
  }

  template <class Target, class Source>
  inline Target* downcast(Source* p, no_convertible, boost::type<Target>* = 0)
  {
      typedef typename base_type_traits<Source>::type base;
      return (Target*)detail::downcast<base>(p, convertible<Source*>::check((base*)0));
  }

  template <class T>
  inline void assert_castable(boost::type<T>* = 0)
  {
      typedef char must_be_a_complete_type[sizeof(T)];
  }

  template <class Source, class Target>
  inline Target* upcast_impl(Source* x, Target*)
  {
      typedef typename add_cv<Source>::type src_t;
      typedef typename add_cv<Target>::type target_t;
      bool const same = is_same<src_t,target_t>::value;

      return detail::upcaster<same>::execute(x, (Target*)0);
  }
}

template <class Target, class Source>
inline Target* upcast(Source* x, Target* = 0)
{
    detail::assert_castable<Source>();
    detail::assert_castable<Target>();
    return detail::upcast_impl(x, (Target*)0);

}

template <class Target, class Source>
inline Target* downcast(Source* x, Target* = 0)
{
    detail::assert_castable<Source>();
    detail::assert_castable<Target>();
    return detail::downcast<Target>(x, detail::convertible<Source*>::check((Target*)0));
}

}}
# 11 "/usr/include/boost-1_42/boost/python/handle.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/errors.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/errors.hpp"
# 1 "/usr/include/boost-1_42/boost/function/function0.hpp" 1
# 11 "/usr/include/boost-1_42/boost/function/function0.hpp"
# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
# 13 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp"
# 1 "/usr/include/boost-1_42/boost/function/function_template.hpp" 1
# 13 "/usr/include/boost-1_42/boost/function/function_template.hpp"
# 1 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 1
# 12 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cassert" 1 3
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cassert" 3
       
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cassert" 2 3
# 13 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/algorithm" 1 3
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/algorithm" 3
       
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/algorithm" 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 1 3
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 2 3
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3






namespace std __attribute__ ((__visibility__ ("default"))) {
# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _FIter, typename _Tp>
    bool
    binary_search(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    bool
    binary_search(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _IIter, typename _OIter>
    _OIter
    copy(_IIter, _IIter, _OIter);

  template<typename _BIter1, typename _BIter2>
    _BIter2
    copy_backward(_BIter1, _BIter1, _BIter2);
# 228 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _FIter, typename _Tp>
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _FIter, typename _Tp>
    void
    fill(_FIter, _FIter, const _Tp&);

  template<typename _OIter, typename _Size, typename _Tp>
    _OIter
    fill_n(_OIter, _Size, const _Tp&);



  template<typename _FIter1, typename _FIter2>
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _IIter1, typename _IIter2>
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _Compare>
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  template<typename _BIter>
    void
    inplace_merge(_BIter, _BIter, _BIter);

  template<typename _BIter, typename _Compare>
    void
    inplace_merge(_BIter, _BIter, _BIter, _Compare);
# 321 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _FIter1, typename _FIter2>
    void
    iter_swap(_FIter1, _FIter2);

  template<typename _FIter, typename _Tp>
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _RAIter>
    void
    make_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    make_heap(_RAIter, _RAIter, _Compare);

  template<typename _Tp>
    const _Tp&
    max(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    const _Tp&
    max(const _Tp&, const _Tp&, _Compare);




  template<typename _Tp>
    const _Tp&
    min(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    const _Tp&
    min(const _Tp&, const _Tp&, _Compare);
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _BIter>
    bool
    next_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
    bool
    next_permutation(_BIter, _BIter, _Compare);
# 423 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _IIter, typename _RAIter>
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);

  template<typename _IIter, typename _RAIter, typename _Compare>
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _RAIter>
    void
    pop_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    pop_heap(_RAIter, _RAIter, _Compare);

  template<typename _BIter>
    bool
    prev_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
    bool
    prev_permutation(_BIter, _BIter, _Compare);

  template<typename _RAIter>
    void
    push_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    push_heap(_RAIter, _RAIter, _Compare);



  template<typename _FIter, typename _Tp>
    _FIter
    remove(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Predicate>
    _FIter
    remove_if(_FIter, _FIter, _Predicate);

  template<typename _IIter, typename _OIter, typename _Tp>
    _OIter
    remove_copy(_IIter, _IIter, _OIter, const _Tp&);

  template<typename _IIter, typename _OIter, typename _Predicate>
    _OIter
    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);



  template<typename _IIter, typename _OIter, typename _Tp>
    _OIter
    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);

  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
    _OIter
    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);



  template<typename _BIter>
    void
    reverse(_BIter, _BIter);

  template<typename _BIter, typename _OIter>
    _OIter
    reverse_copy(_BIter, _BIter, _OIter);

  template<typename _FIter>
    void
    rotate(_FIter, _FIter, _FIter);

  template<typename _FIter, typename _OIter>
    _OIter
    rotate_copy(_FIter, _FIter, _FIter, _OIter);
# 527 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _RAIter>
    void
    sort_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    sort_heap(_RAIter, _RAIter, _Compare);

  template<typename _BIter, typename _Predicate>
    _BIter
    stable_partition(_BIter, _BIter, _Predicate);

  template<typename _Tp>
    void
    swap(_Tp&, _Tp&);

  template<typename _Tp, size_t _Nm>
    void
    swap(_Tp (&)[_Nm], _Tp (&)[_Nm]);

  template<typename _FIter1, typename _FIter2>
    _FIter2
    swap_ranges(_FIter1, _FIter1, _FIter2);



  template<typename _FIter>
    _FIter
    unique(_FIter, _FIter);

  template<typename _FIter, typename _BinaryPredicate>
    _FIter
    unique(_FIter, _FIter, _BinaryPredicate);



  template<typename _FIter, typename _Tp>
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&, _Compare);

}

namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _FIter>
    _FIter
    adjacent_find(_FIter, _FIter);

  template<typename _FIter, typename _BinaryPredicate>
    _FIter
    adjacent_find(_FIter, _FIter, _BinaryPredicate);

  template<typename _IIter, typename _Tp>
    typename iterator_traits<_IIter>::difference_type
    count(_IIter, _IIter, const _Tp&);

  template<typename _IIter, typename _Predicate>
    typename iterator_traits<_IIter>::difference_type
    count_if(_IIter, _IIter, _Predicate);

  template<typename _IIter1, typename _IIter2>
    bool
    equal(_IIter1, _IIter1, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    bool
    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  template<typename _IIter, typename _Tp>
    _IIter
    find(_IIter, _IIter, const _Tp&);

  template<typename _FIter1, typename _FIter2>
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  template<typename _IIter, typename _Predicate>
    _IIter
    find_if(_IIter, _IIter, _Predicate);

  template<typename _IIter, typename _Funct>
    _Funct
    for_each(_IIter, _IIter, _Funct);

  template<typename _FIter, typename _Generator>
    void
    generate(_FIter, _FIter, _Generator);

  template<typename _OIter, typename _Size, typename _Generator>
    _OIter
    generate_n(_OIter, _Size, _Generator);

  template<typename _IIter1, typename _IIter2>
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _Compare>
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  template<typename _FIter>
    _FIter
    max_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    _FIter
    max_element(_FIter, _FIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _FIter>
    _FIter
    min_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    _FIter
    min_element(_FIter, _FIter, _Compare);

  template<typename _IIter1, typename _IIter2>
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  template<typename _RAIter>
    void
    nth_element(_RAIter, _RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    nth_element(_RAIter, _RAIter, _RAIter, _Compare);

  template<typename _RAIter>
    void
    partial_sort(_RAIter, _RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);

  template<typename _BIter, typename _Predicate>
    _BIter
    partition(_BIter, _BIter, _Predicate);

  template<typename _RAIter>
    void
    random_shuffle(_RAIter, _RAIter);

  template<typename _RAIter, typename _Generator>
    void
    random_shuffle(_RAIter, _RAIter,



     _Generator&);


  template<typename _FIter, typename _Tp>
    void
    replace(_FIter, _FIter, const _Tp&, const _Tp&);

  template<typename _FIter, typename _Predicate, typename _Tp>
    void
    replace_if(_FIter, _FIter, _Predicate, const _Tp&);

  template<typename _FIter1, typename _FIter2>
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  template<typename _FIter, typename _Size, typename _Tp>
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&);

  template<typename _FIter, typename _Size, typename _Tp,
    typename _BinaryPredicate>
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
        _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _RAIter>
    void
    sort(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    sort(_RAIter, _RAIter, _Compare);

  template<typename _RAIter>
    void
    stable_sort(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    stable_sort(_RAIter, _RAIter, _Compare);

  template<typename _IIter, typename _OIter, typename _UnaryOperation>
    _OIter
    transform(_IIter, _IIter, _OIter, _UnaryOperation);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _BinaryOperation>
    _OIter
    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);

  template<typename _IIter, typename _OIter>
    _OIter
    unique_copy(_IIter, _IIter, _OIter);

  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
    _OIter
    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);

}
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 1 3
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {






  template<typename _RandomAccessIterator, typename _Distance>
    _Distance
    __is_heap_until(_RandomAccessIterator __first, _Distance __n)
    {
      _Distance __parent = 0;
      for (_Distance __child = 1; __child < __n; ++__child)
 {
   if (__first[__parent] < __first[__child])
     return __child;
   if ((__child & 1) == 0)
     ++__parent;
 }
      return __n;
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Compare>
    _Distance
    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
      _Compare __comp)
    {
      _Distance __parent = 0;
      for (_Distance __child = 1; __child < __n; ++__child)
 {
   if (__comp(__first[__parent], __first[__child]))
     return __child;
   if ((__child & 1) == 0)
     ++__parent;
 }
      return __n;
    }



  template<typename _RandomAccessIterator, typename _Distance>
    inline bool
    __is_heap(_RandomAccessIterator __first, _Distance __n)
    { return std::__is_heap_until(__first, __n) == __n; }

  template<typename _RandomAccessIterator, typename _Compare,
    typename _Distance>
    inline bool
    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
    { return std::__is_heap_until(__first, __n, __comp) == __n; }

  template<typename _RandomAccessIterator>
    inline bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    { return std::__is_heap(__first, std::distance(__first, __last)); }

  template<typename _RandomAccessIterator, typename _Compare>
    inline bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }




  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
    void
    __push_heap(_RandomAccessIterator __first,
  _Distance __holeIndex, _Distance __topIndex, _Tp __value)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex && *(__first + __parent) < __value)
 {
   *(__first + __holeIndex) = (*(__first + __parent));
   __holeIndex = __parent;
   __parent = (__holeIndex - 1) / 2;
 }
      *(__first + __holeIndex) = (__value);
    }
# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

     
      ;
      ;

      _ValueType __value = (*(__last - 1));
      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), (__value));
    }

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
    typename _Compare>
    void
    __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
  _Distance __topIndex, _Tp __value, _Compare __comp)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex
      && __comp(*(__first + __parent), __value))
 {
   *(__first + __holeIndex) = (*(__first + __parent));
   __holeIndex = __parent;
   __parent = (__holeIndex - 1) / 2;
 }
      *(__first + __holeIndex) = (__value);
    }
# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

      ;
      ;

      _ValueType __value = (*(__last - 1));
      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), (__value), __comp);
    }

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
    _Distance __len, _Tp __value)
    {
      const _Distance __topIndex = __holeIndex;
      _Distance __secondChild = __holeIndex;
      while (__secondChild < (__len - 1) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
     __secondChild--;
   *(__first + __holeIndex) = (*(__first + __secondChild));
   __holeIndex = __secondChild;
 }
      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   *(__first + __holeIndex) = (*(__first + (__secondChild - 1)))
                                  ;
   __holeIndex = __secondChild - 1;
 }
      std::__push_heap(__first, __holeIndex, __topIndex,
         (__value));
    }

  template<typename _RandomAccessIterator>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      _ValueType __value = (*__result);
      *__result = (*__first);
      std::__adjust_heap(__first, _DistanceType(0),
    _DistanceType(__last - __first),
    (__value));
    }
# 274 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    inline void
    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      --__last;
      std::__pop_heap(__first, __last, __last);
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Tp, typename _Compare>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
    _Distance __len, _Tp __value, _Compare __comp)
    {
      const _Distance __topIndex = __holeIndex;
      _Distance __secondChild = __holeIndex;
      while (__secondChild < (__len - 1) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   if (__comp(*(__first + __secondChild),
       *(__first + (__secondChild - 1))))
     __secondChild--;
   *(__first + __holeIndex) = (*(__first + __secondChild));
   __holeIndex = __secondChild;
 }
      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   *(__first + __holeIndex) = (*(__first + (__secondChild - 1)))
                                  ;
   __holeIndex = __secondChild - 1;
 }
      std::__push_heap(__first, __holeIndex, __topIndex,
         (__value), __comp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      _ValueType __value = (*__result);
      *__result = (*__first);
      std::__adjust_heap(__first, _DistanceType(0),
    _DistanceType(__last - __first),
    (__value), __comp);
    }
# 348 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    pop_heap(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {

     

      ;
      ;

      --__last;
      std::__pop_heap(__first, __last, __last, __comp);
    }
# 371 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

     
      ;

      if (__last - __first < 2)
 return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
 {
   _ValueType __value = (*(__first + __parent));
   std::__adjust_heap(__first, __parent, __len, (__value));
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 411 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

      ;

      if (__last - __first < 2)
 return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
 {
   _ValueType __value = (*(__first + __parent));
   std::__adjust_heap(__first, __parent, __len, (__value),
        __comp);
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     

      ;
      ;

      while (__last - __first > 1)
 {
   --__last;
   std::__pop_heap(__first, __last, __last);
 }
    }
# 479 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {

     

      ;
      ;

      while (__last - __first > 1)
 {
   --__last;
   std::__pop_heap(__first, __last, __last, __comp);
 }
    }
# 576 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
}
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tempbuf.h" 1 3
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tempbuf.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tempbuf.h" 3
  template<typename _Tp>
    pair<_Tp*, ptrdiff_t>
    get_temporary_buffer(ptrdiff_t __len)
    {
      const ptrdiff_t __max =
 __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
      if (__len > __max)
 __len = __max;

      while (__len > 0)
 {
   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
       std::nothrow));
   if (__tmp != 0)
     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
   __len /= 2;
 }
      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
    }
# 110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tempbuf.h" 3
  template<typename _Tp>
    inline void
    return_temporary_buffer(_Tp* __p)
    { ::operator delete(__p, std::nothrow); }







  template<typename _ForwardIterator, typename _Tp>
    class _Temporary_buffer
    {

     

    public:
      typedef _Tp value_type;
      typedef value_type* pointer;
      typedef pointer iterator;
      typedef ptrdiff_t size_type;

    protected:
      size_type _M_original_len;
      size_type _M_len;
      pointer _M_buffer;

    public:

      size_type
      size() const
      { return _M_len; }


      size_type
      requested_size() const
      { return _M_original_len; }


      iterator
      begin()
      { return _M_buffer; }


      iterator
      end()
      { return _M_buffer + _M_len; }





      _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);

      ~_Temporary_buffer()
      {
 std::_Destroy(_M_buffer, _M_buffer + _M_len);
 std::return_temporary_buffer(_M_buffer);
      }

    private:

      _Temporary_buffer(const _Temporary_buffer&);

      void
      operator=(const _Temporary_buffer&);
    };

  template<typename _ForwardIterator, typename _Tp>
    _Temporary_buffer<_ForwardIterator, _Tp>::
    _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
    : _M_original_len(std::distance(__first, __last)),
      _M_len(0), _M_buffer(0)
    {
      try
 {
   std::pair<pointer, size_type> __p(std::get_temporary_buffer<
         value_type>(_M_original_len));
   _M_buffer = __p.first;
   _M_len = __p.second;
   if(_M_buffer)
     std::__uninitialized_construct_range(_M_buffer, _M_buffer + _M_len,
       *__first);
 }
      catch(...)
 {
   std::return_temporary_buffer(_M_buffer);
   _M_buffer = 0;
   _M_len = 0;
   throw;
 }
    }

}
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 2 3







namespace std __attribute__ ((__visibility__ ("default"))) {


  template<typename _Iterator>
    void
    __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c)
    {

     


      if (*__a < *__b)
 {
   if (*__b < *__c)
     std::iter_swap(__a, __b);
   else if (*__a < *__c)
     std::iter_swap(__a, __c);
 }
      else if (*__a < *__c)
 return;
      else if (*__b < *__c)
 std::iter_swap(__a, __c);
      else
 std::iter_swap(__a, __b);
    }


  template<typename _Iterator, typename _Compare>
    void
    __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c,
   _Compare __comp)
    {

     



      if (__comp(*__a, *__b))
 {
   if (__comp(*__b, *__c))
     std::iter_swap(__a, __b);
   else if (__comp(*__a, *__c))
     std::iter_swap(__a, __c);
 }
      else if (__comp(*__a, *__c))
 return;
      else if (__comp(*__b, *__c))
 std::iter_swap(__a, __c);
      else
 std::iter_swap(__a, __b);
    }




  template<typename _InputIterator, typename _Tp>
    inline _InputIterator
    __find(_InputIterator __first, _InputIterator __last,
    const _Tp& __val, input_iterator_tag)
    {
      while (__first != __last && !(*__first == __val))
 ++__first;
      return __first;
    }


  template<typename _InputIterator, typename _Predicate>
    inline _InputIterator
    __find_if(_InputIterator __first, _InputIterator __last,
       _Predicate __pred, input_iterator_tag)
    {
      while (__first != __last && !bool(__pred(*__first)))
 ++__first;
      return __first;
    }


  template<typename _RandomAccessIterator, typename _Tp>
    _RandomAccessIterator
    __find(_RandomAccessIterator __first, _RandomAccessIterator __last,
    const _Tp& __val, random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIterator>::difference_type
 __trip_count = (__last - __first) >> 2;

      for (; __trip_count > 0; --__trip_count)
 {
   if (*__first == __val)
     return __first;
   ++__first;

   if (*__first == __val)
     return __first;
   ++__first;

   if (*__first == __val)
     return __first;
   ++__first;

   if (*__first == __val)
     return __first;
   ++__first;
 }

      switch (__last - __first)
 {
 case 3:
   if (*__first == __val)
     return __first;
   ++__first;
 case 2:
   if (*__first == __val)
     return __first;
   ++__first;
 case 1:
   if (*__first == __val)
     return __first;
   ++__first;
 case 0:
 default:
   return __last;
 }
    }


  template<typename _RandomAccessIterator, typename _Predicate>
    _RandomAccessIterator
    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Predicate __pred, random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIterator>::difference_type
 __trip_count = (__last - __first) >> 2;

      for (; __trip_count > 0; --__trip_count)
 {
   if (__pred(*__first))
     return __first;
   ++__first;

   if (__pred(*__first))
     return __first;
   ++__first;

   if (__pred(*__first))
     return __first;
   ++__first;

   if (__pred(*__first))
     return __first;
   ++__first;
 }

      switch (__last - __first)
 {
 case 3:
   if (__pred(*__first))
     return __first;
   ++__first;
 case 2:
   if (__pred(*__first))
     return __first;
   ++__first;
 case 1:
   if (__pred(*__first))
     return __first;
   ++__first;
 case 0:
 default:
   return __last;
 }
    }
# 322 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp>
    _ForwardIterator
    __search_n(_ForwardIterator __first, _ForwardIterator __last,
        _Integer __count, const _Tp& __val,
        std::forward_iterator_tag)
    {
      __first = std::find(__first, __last, __val);
      while (__first != __last)
 {
   typename iterator_traits<_ForwardIterator>::difference_type
     __n = __count;
   _ForwardIterator __i = __first;
   ++__i;
   while (__i != __last && __n != 1 && *__i == __val)
     {
       ++__i;
       --__n;
     }
   if (__n == 1)
     return __first;
   if (__i == __last)
     return __last;
   __first = std::find(++__i, __last, __val);
 }
      return __last;
    }






  template<typename _RandomAccessIter, typename _Integer, typename _Tp>
    _RandomAccessIter
    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
        _Integer __count, const _Tp& __val,
        std::random_access_iterator_tag)
    {

      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
 _DistanceType;

      _DistanceType __tailSize = __last - __first;
      const _DistanceType __pattSize = __count;

      if (__tailSize < __pattSize)
        return __last;

      const _DistanceType __skipOffset = __pattSize - 1;
      _RandomAccessIter __lookAhead = __first + __skipOffset;
      __tailSize -= __pattSize;

      while (1)
 {


   while (!(*__lookAhead == __val))
     {
       if (__tailSize < __pattSize)
  return __last;
       __lookAhead += __pattSize;
       __tailSize -= __pattSize;
     }
   _DistanceType __remainder = __skipOffset;
   for (_RandomAccessIter __backTrack = __lookAhead - 1;
        *__backTrack == __val; --__backTrack)
     {
       if (--__remainder == 0)
  return (__lookAhead - __skipOffset);
     }
   if (__remainder > __tailSize)
     return __last;
   __lookAhead += __remainder;
   __tailSize -= __remainder;
 }
    }
# 407 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp,
           typename _BinaryPredicate>
    _ForwardIterator
    __search_n(_ForwardIterator __first, _ForwardIterator __last,
        _Integer __count, const _Tp& __val,
        _BinaryPredicate __binary_pred, std::forward_iterator_tag)
    {
      while (__first != __last && !bool(__binary_pred(*__first, __val)))
        ++__first;

      while (__first != __last)
 {
   typename iterator_traits<_ForwardIterator>::difference_type
     __n = __count;
   _ForwardIterator __i = __first;
   ++__i;
   while (__i != __last && __n != 1 && bool(__binary_pred(*__i, __val)))
     {
       ++__i;
       --__n;
     }
   if (__n == 1)
     return __first;
   if (__i == __last)
     return __last;
   __first = ++__i;
   while (__first != __last
   && !bool(__binary_pred(*__first, __val)))
     ++__first;
 }
      return __last;
    }







  template<typename _RandomAccessIter, typename _Integer, typename _Tp,
    typename _BinaryPredicate>
    _RandomAccessIter
    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
        _Integer __count, const _Tp& __val,
        _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
    {

      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
 _DistanceType;

      _DistanceType __tailSize = __last - __first;
      const _DistanceType __pattSize = __count;

      if (__tailSize < __pattSize)
        return __last;

      const _DistanceType __skipOffset = __pattSize - 1;
      _RandomAccessIter __lookAhead = __first + __skipOffset;
      __tailSize -= __pattSize;

      while (1)
 {


   while (!bool(__binary_pred(*__lookAhead, __val)))
     {
       if (__tailSize < __pattSize)
  return __last;
       __lookAhead += __pattSize;
       __tailSize -= __pattSize;
     }
   _DistanceType __remainder = __skipOffset;
   for (_RandomAccessIter __backTrack = __lookAhead - 1;
        __binary_pred(*__backTrack, __val); --__backTrack)
     {
       if (--__remainder == 0)
  return (__lookAhead - __skipOffset);
     }
   if (__remainder > __tailSize)
     return __last;
   __lookAhead += __remainder;
   __tailSize -= __remainder;
 }
    }


  template<typename _ForwardIterator1, typename _ForwardIterator2>
    _ForwardIterator1
    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
        forward_iterator_tag, forward_iterator_tag)
    {
      if (__first2 == __last2)
 return __last1;
      else
 {
   _ForwardIterator1 __result = __last1;
   while (1)
     {
       _ForwardIterator1 __new_result
  = std::search(__first1, __last1, __first2, __last2);
       if (__new_result == __last1)
  return __result;
       else
  {
    __result = __new_result;
    __first1 = __new_result;
    ++__first1;
  }
     }
 }
    }

  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    _ForwardIterator1
    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
        forward_iterator_tag, forward_iterator_tag,
        _BinaryPredicate __comp)
    {
      if (__first2 == __last2)
 return __last1;
      else
 {
   _ForwardIterator1 __result = __last1;
   while (1)
     {
       _ForwardIterator1 __new_result
  = std::search(__first1, __last1, __first2,
      __last2, __comp);
       if (__new_result == __last1)
  return __result;
       else
  {
    __result = __new_result;
    __first1 = __new_result;
    ++__first1;
  }
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
    _BidirectionalIterator1
    __find_end(_BidirectionalIterator1 __first1,
        _BidirectionalIterator1 __last1,
        _BidirectionalIterator2 __first2,
        _BidirectionalIterator2 __last2,
        bidirectional_iterator_tag, bidirectional_iterator_tag)
    {

     

     


      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

      _RevIterator1 __rlast1(__first1);
      _RevIterator2 __rlast2(__first2);
      _RevIterator1 __rresult = std::search(_RevIterator1(__last1),
             __rlast1,
             _RevIterator2(__last2),
             __rlast2);

      if (__rresult == __rlast1)
 return __last1;
      else
 {
   _BidirectionalIterator1 __result = __rresult.base();
   std::advance(__result, -std::distance(__first2, __last2));
   return __result;
 }
    }

  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BinaryPredicate>
    _BidirectionalIterator1
    __find_end(_BidirectionalIterator1 __first1,
        _BidirectionalIterator1 __last1,
        _BidirectionalIterator2 __first2,
        _BidirectionalIterator2 __last2,
        bidirectional_iterator_tag, bidirectional_iterator_tag,
        _BinaryPredicate __comp)
    {

     

     


      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

      _RevIterator1 __rlast1(__first1);
      _RevIterator2 __rlast2(__first2);
      _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
         _RevIterator2(__last2), __rlast2,
         __comp);

      if (__rresult == __rlast1)
 return __last1;
      else
 {
   _BidirectionalIterator1 __result = __rresult.base();
   std::advance(__result, -std::distance(__first2, __last2));
   return __result;
 }
    }
# 645 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    inline _ForwardIterator1
    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {

     
     
     


      ;
      ;

      return std::__find_end(__first1, __last1, __first2, __last2,
        std::__iterator_category(__first1),
        std::__iterator_category(__first2));
    }
# 691 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    inline _ForwardIterator1
    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      _BinaryPredicate __comp)
    {

     
     
     


      ;
      ;

      return std::__find_end(__first1, __last1, __first2, __last2,
        std::__iterator_category(__first1),
        std::__iterator_category(__first2),
        __comp);
    }
# 870 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    _OutputIterator
    remove_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, const _Tp& __value)
    {

     
     

     

      ;

      for (; __first != __last; ++__first)
 if (!(*__first == __value))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }
# 907 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
    _OutputIterator
    remove_copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
    {

     
     

     

      ;

      for (; __first != __last; ++__first)
 if (!bool(__pred(*__first)))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }
# 1082 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    _ForwardIterator
    remove(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __value)
    {

     

     

      ;

      __first = std::find(__first, __last, __value);
      if(__first == __last)
        return __first;
      _ForwardIterator __result = __first;
      ++__first;
      for(; __first != __last; ++__first)
        if(!(*__first == __value))
          {
            *__result = (*__first);
            ++__result;
          }
      return __result;
    }
# 1125 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    remove_if(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      __first = std::find_if(__first, __last, __pred);
      if(__first == __last)
        return __first;
      _ForwardIterator __result = __first;
      ++__first;
      for(; __first != __last; ++__first)
        if(!bool(__pred(*__first)))
          {
            *__result = (*__first);
            ++__result;
          }
      return __result;
    }
# 1165 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last)
    {

     

     

      ;


      __first = std::adjacent_find(__first, __last);
      if (__first == __last)
 return __last;


      _ForwardIterator __dest = __first;
      ++__first;
      while (++__first != __last)
 if (!(*__dest == *__first))
   *++__dest = (*__first);
      return ++__dest;
    }
# 1205 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
    _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last,
           _BinaryPredicate __binary_pred)
    {

     

     


      ;


      __first = std::adjacent_find(__first, __last, __binary_pred);
      if (__first == __last)
 return __last;


      _ForwardIterator __dest = __first;
      ++__first;
      while (++__first != __last)
 if (!bool(__binary_pred(*__dest, *__first)))
   *++__dest = (*__first);
      return ++__dest;
    }






  template<typename _ForwardIterator, typename _OutputIterator>
    _OutputIterator
    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
    _OutputIterator __result,
    forward_iterator_tag, output_iterator_tag)
    {

      _ForwardIterator __next = __first;
      *__result = *__first;
      while (++__next != __last)
 if (!(*__first == *__next))
   {
     __first = __next;
     *++__result = *__first;
   }
      return ++__result;
    }






  template<typename _InputIterator, typename _OutputIterator>
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result,
    input_iterator_tag, output_iterator_tag)
    {

      typename iterator_traits<_InputIterator>::value_type __value = *__first;
      *__result = __value;
      while (++__first != __last)
 if (!(__value == *__first))
   {
     __value = *__first;
     *++__result = __value;
   }
      return ++__result;
    }






  template<typename _InputIterator, typename _ForwardIterator>
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result,
    input_iterator_tag, forward_iterator_tag)
    {

      *__result = *__first;
      while (++__first != __last)
 if (!(*__result == *__first))
   *++__result = *__first;
      return ++__result;
    }







  template<typename _ForwardIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    _OutputIterator
    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
    _OutputIterator __result, _BinaryPredicate __binary_pred,
    forward_iterator_tag, output_iterator_tag)
    {

     



      _ForwardIterator __next = __first;
      *__result = *__first;
      while (++__next != __last)
 if (!bool(__binary_pred(*__first, *__next)))
   {
     __first = __next;
     *++__result = *__first;
   }
      return ++__result;
    }







  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result, _BinaryPredicate __binary_pred,
    input_iterator_tag, output_iterator_tag)
    {

     



      typename iterator_traits<_InputIterator>::value_type __value = *__first;
      *__result = __value;
      while (++__first != __last)
 if (!bool(__binary_pred(__value, *__first)))
   {
     __value = *__first;
     *++__result = __value;
   }
      return ++__result;
    }







  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result, _BinaryPredicate __binary_pred,
    input_iterator_tag, forward_iterator_tag)
    {

     



      *__result = *__first;
      while (++__first != __last)
 if (!bool(__binary_pred(*__result, *__first)))
   *++__result = *__first;
      return ++__result;
    }






  template<typename _BidirectionalIterator>
    void
    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {
      while (true)
 if (__first == __last || __first == --__last)
   return;
 else
   {
     std::iter_swap(__first, __last);
     ++__first;
   }
    }






  template<typename _RandomAccessIterator>
    void
    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
       random_access_iterator_tag)
    {
      if (__first == __last)
 return;
      --__last;
      while (__first < __last)
 {
   std::iter_swap(__first, __last);
   ++__first;
   --__last;
 }
    }
# 1433 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    inline void
    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    {

     

      ;
      std::__reverse(__first, __last, std::__iterator_category(__first));
    }
# 1460 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _OutputIterator>
    _OutputIterator
    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
   _OutputIterator __result)
    {

     

     

      ;

      while (__first != __last)
 {
   --__last;
   *__result = *__last;
   ++__result;
 }
      return __result;
    }





  template<typename _EuclideanRingElement>
    _EuclideanRingElement
    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
    {
      while (__n != 0)
 {
   _EuclideanRingElement __t = __m % __n;
   __m = __n;
   __n = __t;
 }
      return __m;
    }


  template<typename _ForwardIterator>
    void
    __rotate(_ForwardIterator __first,
      _ForwardIterator __middle,
      _ForwardIterator __last,
      forward_iterator_tag)
    {
      if (__first == __middle || __last == __middle)
 return;

      _ForwardIterator __first2 = __middle;
      do
 {
   std::iter_swap(__first, __first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
 }
      while (__first2 != __last);

      __first2 = __middle;

      while (__first2 != __last)
 {
   std::iter_swap(__first, __first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
   else if (__first2 == __last)
     __first2 = __middle;
 }
    }


  template<typename _BidirectionalIterator>
    void
    __rotate(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {

     


      if (__first == __middle || __last == __middle)
 return;

      std::__reverse(__first, __middle, bidirectional_iterator_tag());
      std::__reverse(__middle, __last, bidirectional_iterator_tag());

      while (__first != __middle && __middle != __last)
 {
   std::iter_swap(__first, --__last);
   ++__first;
 }

      if (__first == __middle)
 std::__reverse(__middle, __last, bidirectional_iterator_tag());
      else
 std::__reverse(__first, __middle, bidirectional_iterator_tag());
    }


  template<typename _RandomAccessIterator>
    void
    __rotate(_RandomAccessIterator __first,
      _RandomAccessIterator __middle,
      _RandomAccessIterator __last,
      random_access_iterator_tag)
    {

     


      if (__first == __middle || __last == __middle)
 return;

      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      _Distance __n = __last - __first;
      _Distance __k = __middle - __first;

      if (__k == __n - __k)
 {
   std::swap_ranges(__first, __middle, __middle);
   return;
 }

      _RandomAccessIterator __p = __first;

      for (;;)
 {
   if (__k < __n - __k)
     {
       if (__is_pod(_ValueType) && __k == 1)
  {
    _ValueType __t = (*__p);
    std::copy(__p + 1, __p + __n, __p);
    *(__p + __n - 1) = (__t);
    return;
  }
       _RandomAccessIterator __q = __p + __k;
       for (_Distance __i = 0; __i < __n - __k; ++ __i)
  {
    std::iter_swap(__p, __q);
    ++__p;
    ++__q;
  }
       __n %= __k;
       if (__n == 0)
  return;
       std::swap(__n, __k);
       __k = __n - __k;
     }
   else
     {
       __k = __n - __k;
       if (__is_pod(_ValueType) && __k == 1)
  {
    _ValueType __t = (*(__p + __n - 1));
    std::copy_backward(__p, __p + __n - 1, __p + __n);
    *__p = (__t);
    return;
  }
       _RandomAccessIterator __q = __p + __n;
       __p = __q - __k;
       for (_Distance __i = 0; __i < __n - __k; ++ __i)
  {
    --__p;
    --__q;
    std::iter_swap(__p, __q);
  }
       __n %= __k;
       if (__n == 0)
  return;
       std::swap(__n, __k);
     }
 }
    }
# 1664 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    inline void
    rotate(_ForwardIterator __first, _ForwardIterator __middle,
    _ForwardIterator __last)
    {

     

      ;
      ;

      typedef typename iterator_traits<_ForwardIterator>::iterator_category
 _IterType;
      std::__rotate(__first, __middle, __last, _IterType());
    }
# 1698 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _OutputIterator>
    _OutputIterator
    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
                _ForwardIterator __last, _OutputIterator __result)
    {

     
     

      ;
      ;

      return std::copy(__first, __middle,
                       std::copy(__middle, __last, __result));
    }


  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    __partition(_ForwardIterator __first, _ForwardIterator __last,
  _Predicate __pred, forward_iterator_tag)
    {
      if (__first == __last)
 return __first;

      while (__pred(*__first))
 if (++__first == __last)
   return __first;

      _ForwardIterator __next = __first;

      while (++__next != __last)
 if (__pred(*__next))
   {
     std::iter_swap(__first, __next);
     ++__first;
   }

      return __first;
    }


  template<typename _BidirectionalIterator, typename _Predicate>
    _BidirectionalIterator
    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
  _Predicate __pred, bidirectional_iterator_tag)
    {
      while (true)
 {
   while (true)
     if (__first == __last)
       return __first;
     else if (__pred(*__first))
       ++__first;
     else
       break;
   --__last;
   while (true)
     if (__first == __last)
       return __first;
     else if (!bool(__pred(*__last)))
       --__last;
     else
       break;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }




  template<typename _ForwardIterator, typename _Predicate, typename _Distance>
    _ForwardIterator
    __inplace_stable_partition(_ForwardIterator __first,
          _ForwardIterator __last,
          _Predicate __pred, _Distance __len)
    {
      if (__len == 1)
 return __pred(*__first) ? __last : __first;
      _ForwardIterator __middle = __first;
      std::advance(__middle, __len / 2);
      _ForwardIterator __begin = std::__inplace_stable_partition(__first,
         __middle,
         __pred,
         __len / 2);
      _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last,
              __pred,
              __len
              - __len / 2);
      std::rotate(__begin, __middle, __end);
      std::advance(__begin, std::distance(__middle, __end));
      return __begin;
    }


  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
    typename _Distance>
    _ForwardIterator
    __stable_partition_adaptive(_ForwardIterator __first,
    _ForwardIterator __last,
    _Predicate __pred, _Distance __len,
    _Pointer __buffer,
    _Distance __buffer_size)
    {
      if (__len <= __buffer_size)
 {
   _ForwardIterator __result1 = __first;
   _Pointer __result2 = __buffer;
   for (; __first != __last; ++__first)
     if (__pred(*__first))
       {
  *__result1 = (*__first);
  ++__result1;
       }
     else
       {
  *__result2 = (*__first);
  ++__result2;
       }
   std::copy(__buffer, __result2, __result1);
   return __result1;
 }
      else
 {
   _ForwardIterator __middle = __first;
   std::advance(__middle, __len / 2);
   _ForwardIterator __begin =
     std::__stable_partition_adaptive(__first, __middle, __pred,
          __len / 2, __buffer,
          __buffer_size);
   _ForwardIterator __end =
     std::__stable_partition_adaptive(__middle, __last, __pred,
          __len - __len / 2,
          __buffer, __buffer_size);
   std::rotate(__begin, __middle, __end);
   std::advance(__begin, std::distance(__middle, __end));
   return __begin;
 }
    }
# 1856 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      if (__first == __last)
 return __first;
      else
 {
   typedef typename iterator_traits<_ForwardIterator>::value_type
     _ValueType;
   typedef typename iterator_traits<_ForwardIterator>::difference_type
     _DistanceType;

   _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
        __last);
 if (__buf.size() > 0)
   return
     std::__stable_partition_adaptive(__first, __last, __pred,
       _DistanceType(__buf.requested_size()),
       __buf.begin(),
       _DistanceType(__buf.size()));
 else
   return
     std::__inplace_stable_partition(__first, __last, __pred,
      _DistanceType(__buf.requested_size()));
 }
    }


  template<typename _RandomAccessIterator>
    void
    __heap_select(_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last)
    {
      std::make_heap(__first, __middle);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (*__i < *__first)
   std::__pop_heap(__first, __middle, __i);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    void
    __heap_select(_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last, _Compare __comp)
    {
      std::make_heap(__first, __middle, __comp);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (__comp(*__i, *__first))
   std::__pop_heap(__first, __middle, __i, __comp);
    }
# 1938 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _RandomAccessIterator>
    _RandomAccessIterator
    partial_sort_copy(_InputIterator __first, _InputIterator __last,
        _RandomAccessIterator __result_first,
        _RandomAccessIterator __result_last)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _InputValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _OutputValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;


     
     

     

     
      ;
      ;

      if (__result_first == __result_last)
 return __result_last;
      _RandomAccessIterator __result_real_last = __result_first;
      while(__first != __last && __result_real_last != __result_last)
 {
   *__result_real_last = *__first;
   ++__result_real_last;
   ++__first;
 }
      std::make_heap(__result_first, __result_real_last);
      while (__first != __last)
 {
   if (*__first < *__result_first)
     std::__adjust_heap(__result_first, _DistanceType(0),
          _DistanceType(__result_real_last
          - __result_first),
          _InputValueType(*__first));
   ++__first;
 }
      std::sort_heap(__result_first, __result_real_last);
      return __result_real_last;
    }
# 2004 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
    _RandomAccessIterator
    partial_sort_copy(_InputIterator __first, _InputIterator __last,
        _RandomAccessIterator __result_first,
        _RandomAccessIterator __result_last,
        _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _InputValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _OutputValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;


     
     

     

     

     

      ;
      ;

      if (__result_first == __result_last)
 return __result_last;
      _RandomAccessIterator __result_real_last = __result_first;
      while(__first != __last && __result_real_last != __result_last)
 {
   *__result_real_last = *__first;
   ++__result_real_last;
   ++__first;
 }
      std::make_heap(__result_first, __result_real_last, __comp);
      while (__first != __last)
 {
   if (__comp(*__first, *__result_first))
     std::__adjust_heap(__result_first, _DistanceType(0),
          _DistanceType(__result_real_last
          - __result_first),
          _InputValueType(*__first),
          __comp);
   ++__first;
 }
      std::sort_heap(__result_first, __result_real_last, __comp);
      return __result_real_last;
    }


  template<typename _RandomAccessIterator>
    void
    __unguarded_linear_insert(_RandomAccessIterator __last)
    {
      typename iterator_traits<_RandomAccessIterator>::value_type
 __val = (*__last);
      _RandomAccessIterator __next = __last;
      --__next;
      while (__val < *__next)
 {
   *__last = (*__next);
   __last = __next;
   --__next;
 }
      *__last = (__val);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    void
    __unguarded_linear_insert(_RandomAccessIterator __last,
         _Compare __comp)
    {
      typename iterator_traits<_RandomAccessIterator>::value_type
 __val = (*__last);
      _RandomAccessIterator __next = __last;
      --__next;
      while (__comp(__val, *__next))
 {
   *__last = (*__next);
   __last = __next;
   --__next;
 }
      *__last = (__val);
    }


  template<typename _RandomAccessIterator>
    void
    __insertion_sort(_RandomAccessIterator __first,
       _RandomAccessIterator __last)
    {
      if (__first == __last)
 return;

      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   if (*__i < *__first)
     {
       typename iterator_traits<_RandomAccessIterator>::value_type
  __val = (*__i);
       std::copy_backward(__first, __i, __i + 1);
       *__first = (__val);
     }
   else
     std::__unguarded_linear_insert(__i);
 }
    }


  template<typename _RandomAccessIterator, typename _Compare>
    void
    __insertion_sort(_RandomAccessIterator __first,
       _RandomAccessIterator __last, _Compare __comp)
    {
      if (__first == __last) return;

      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   if (__comp(*__i, *__first))
     {
       typename iterator_traits<_RandomAccessIterator>::value_type
  __val = (*__i);
       std::copy_backward(__first, __i, __i + 1);
       *__first = (__val);
     }
   else
     std::__unguarded_linear_insert(__i, __comp);
 }
    }


  template<typename _RandomAccessIterator>
    inline void
    __unguarded_insertion_sort(_RandomAccessIterator __first,
          _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 std::__unguarded_linear_insert(__i);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    __unguarded_insertion_sort(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 std::__unguarded_linear_insert(__i, __comp);
    }





  enum { _S_threshold = 16 };


  template<typename _RandomAccessIterator>
    void
    __final_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last)
    {
      if (__last - __first > int(_S_threshold))
 {
   std::__insertion_sort(__first, __first + int(_S_threshold));
   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
 }
      else
 std::__insertion_sort(__first, __last);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    void
    __final_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first > int(_S_threshold))
 {
   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
       __comp);
 }
      else
 std::__insertion_sort(__first, __last, __comp);
    }


  template<typename _RandomAccessIterator, typename _Tp>
    _RandomAccessIterator
    __unguarded_partition(_RandomAccessIterator __first,
     _RandomAccessIterator __last, const _Tp& __pivot)
    {
      while (true)
 {
   while (*__first < __pivot)
     ++__first;
   --__last;
   while (__pivot < *__last)
     --__last;
   if (!(__first < __last))
     return __first;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }


  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
    _RandomAccessIterator
    __unguarded_partition(_RandomAccessIterator __first,
     _RandomAccessIterator __last,
     const _Tp& __pivot, _Compare __comp)
    {
      while (true)
 {
   while (__comp(*__first, __pivot))
     ++__first;
   --__last;
   while (__comp(__pivot, *__last))
     --__last;
   if (!(__first < __last))
     return __first;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }


  template<typename _RandomAccessIterator>
    inline _RandomAccessIterator
    __unguarded_partition_pivot(_RandomAccessIterator __first,
    _RandomAccessIterator __last)
    {
      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
      std::__move_median_first(__first, __mid, (__last - 1));
      return std::__unguarded_partition(__first + 1, __last, *__first);
    }



  template<typename _RandomAccessIterator, typename _Compare>
    inline _RandomAccessIterator
    __unguarded_partition_pivot(_RandomAccessIterator __first,
    _RandomAccessIterator __last, _Compare __comp)
    {
      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
      std::__move_median_first(__first, __mid, (__last - 1), __comp);
      return std::__unguarded_partition(__first + 1, __last, *__first, __comp);
    }


  template<typename _RandomAccessIterator, typename _Size>
    void
    __introsort_loop(_RandomAccessIterator __first,
       _RandomAccessIterator __last,
       _Size __depth_limit)
    {
      while (__last - __first > int(_S_threshold))
 {
   if (__depth_limit == 0)
     {
       std::partial_sort(__first, __last, __last);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition_pivot(__first, __last);
   std::__introsort_loop(__cut, __last, __depth_limit);
   __last = __cut;
 }
    }


  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    void
    __introsort_loop(_RandomAccessIterator __first,
       _RandomAccessIterator __last,
       _Size __depth_limit, _Compare __comp)
    {
      while (__last - __first > int(_S_threshold))
 {
   if (__depth_limit == 0)
     {
       std::partial_sort(__first, __last, __last, __comp);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition_pivot(__first, __last, __comp);
   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
   __last = __cut;
 }
    }



  template<typename _RandomAccessIterator, typename _Size>
    void
    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    _RandomAccessIterator __last, _Size __depth_limit)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      while (__last - __first > 3)
 {
   if (__depth_limit == 0)
     {
       std::__heap_select(__first, __nth + 1, __last);


       std::iter_swap(__first, __nth);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition_pivot(__first, __last);
   if (__cut <= __nth)
     __first = __cut;
   else
     __last = __cut;
 }
      std::__insertion_sort(__first, __last);
    }

  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    void
    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    _RandomAccessIterator __last, _Size __depth_limit,
    _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      while (__last - __first > 3)
 {
   if (__depth_limit == 0)
     {
       std::__heap_select(__first, __nth + 1, __last, __comp);

       std::iter_swap(__first, __nth);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition_pivot(__first, __last, __comp);
   if (__cut <= __nth)
     __first = __cut;
   else
     __last = __cut;
 }
      std::__insertion_sort(__first, __last, __comp);
    }
# 2388 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;


     
     

     
                    ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__comp(*__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }
# 2437 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    _ForwardIterator
    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;


     
     
      ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__val < *__middle)
     __len = __half;
   else
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
 }
      return __first;
    }
# 2488 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    _ForwardIterator
    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;


     
     

     
                    ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__comp(__val, *__middle))
     __len = __half;
   else
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
 }
      return __first;
    }
# 2543 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    pair<_ForwardIterator, _ForwardIterator>
    equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;


     
     
     
      ;
      ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle, __left, __right;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (*__middle < __val)
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else if (__val < *__middle)
     __len = __half;
   else
     {
       __left = std::lower_bound(__first, __middle, __val);
       std::advance(__first, __len);
       __right = std::upper_bound(++__middle, __first, __val);
       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
     }
 }
      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    }
# 2605 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    pair<_ForwardIterator, _ForwardIterator>
    equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val,
  _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;


     
     

     

     
                    ;
     
                    ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle, __left, __right;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__comp(*__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else if (__comp(__val, *__middle))
     __len = __half;
   else
     {
       __left = std::lower_bound(__first, __middle, __val, __comp);
       std::advance(__first, __len);
       __right = std::upper_bound(++__middle, __first, __val, __comp);
       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
     }
 }
      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    }
# 2666 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
                  const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;


     
     
      ;
      ;

      _ForwardIterator __i = std::lower_bound(__first, __last, __val);
      return __i != __last && !(__val < *__i);
    }
# 2699 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
                  const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;


     
     

     
                    ;
     
                    ;

      _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
      return __i != __last && !bool(__comp(__val, *__i));
    }




  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BidirectionalIterator3>
    _BidirectionalIterator3
    __merge_backward(_BidirectionalIterator1 __first1,
       _BidirectionalIterator1 __last1,
       _BidirectionalIterator2 __first2,
       _BidirectionalIterator2 __last2,
       _BidirectionalIterator3 __result)
    {
      if (__first1 == __last1)
 return std::copy_backward(__first2, __last2, __result);
      if (__first2 == __last2)
 return std::copy_backward(__first1, __last1, __result);
      --__last1;
      --__last2;
      while (true)
 {
   if (*__last2 < *__last1)
     {
       *--__result = *__last1;
       if (__first1 == __last1)
  return std::copy_backward(__first2, ++__last2, __result);
       --__last1;
     }
   else
     {
       *--__result = *__last2;
       if (__first2 == __last2)
  return std::copy_backward(__first1, ++__last1, __result);
       --__last2;
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BidirectionalIterator3, typename _Compare>
    _BidirectionalIterator3
    __merge_backward(_BidirectionalIterator1 __first1,
       _BidirectionalIterator1 __last1,
       _BidirectionalIterator2 __first2,
       _BidirectionalIterator2 __last2,
       _BidirectionalIterator3 __result,
       _Compare __comp)
    {
      if (__first1 == __last1)
 return std::copy_backward(__first2, __last2, __result);
      if (__first2 == __last2)
 return std::copy_backward(__first1, __last1, __result);
      --__last1;
      --__last2;
      while (true)
 {
   if (__comp(*__last2, *__last1))
     {
       *--__result = *__last1;
       if (__first1 == __last1)
  return std::copy_backward(__first2, ++__last2, __result);
       --__last1;
     }
   else
     {
       *--__result = *__last2;
       if (__first2 == __last2)
  return std::copy_backward(__first1, ++__last1, __result);
       --__last2;
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _Distance>
    _BidirectionalIterator1
    __rotate_adaptive(_BidirectionalIterator1 __first,
        _BidirectionalIterator1 __middle,
        _BidirectionalIterator1 __last,
        _Distance __len1, _Distance __len2,
        _BidirectionalIterator2 __buffer,
        _Distance __buffer_size)
    {
      _BidirectionalIterator2 __buffer_end;
      if (__len1 > __len2 && __len2 <= __buffer_size)
 {
   __buffer_end = std::copy(__middle, __last, __buffer);
   std::copy_backward(__first, __middle, __last);
   return std::copy(__buffer, __buffer_end, __first);
 }
      else if (__len1 <= __buffer_size)
 {
   __buffer_end = std::copy(__first, __middle, __buffer);
   std::copy(__middle, __last, __first);
   return std::copy_backward(__buffer, __buffer_end, __last);
 }
      else
 {
   std::rotate(__first, __middle, __last);
   std::advance(__first, std::distance(__middle, __last));
   return __first;
 }
    }


  template<typename _BidirectionalIterator, typename _Distance,
    typename _Pointer>
    void
    __merge_adaptive(_BidirectionalIterator __first,
                     _BidirectionalIterator __middle,
       _BidirectionalIterator __last,
       _Distance __len1, _Distance __len2,
       _Pointer __buffer, _Distance __buffer_size)
    {
      if (__len1 <= __len2 && __len1 <= __buffer_size)
 {
   _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
   std::merge((__buffer),
    (__buffer_end),
    (__middle),
    (__last),
    __first);
 }
      else if (__len2 <= __buffer_size)
 {
   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
   std::__merge_backward((__first),
    (__middle),
    (__buffer),
    (__buffer_end),
    __last);
 }
      else
 {
   _BidirectionalIterator __first_cut = __first;
   _BidirectionalIterator __second_cut = __middle;
   _Distance __len11 = 0;
   _Distance __len22 = 0;
   if (__len1 > __len2)
     {
       __len11 = __len1 / 2;
       std::advance(__first_cut, __len11);
       __second_cut = std::lower_bound(__middle, __last,
           *__first_cut);
       __len22 = std::distance(__middle, __second_cut);
     }
   else
     {
       __len22 = __len2 / 2;
       std::advance(__second_cut, __len22);
       __first_cut = std::upper_bound(__first, __middle,
          *__second_cut);
       __len11 = std::distance(__first, __first_cut);
     }
   _BidirectionalIterator __new_middle =
     std::__rotate_adaptive(__first_cut, __middle, __second_cut,
       __len1 - __len11, __len22, __buffer,
       __buffer_size);
   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
    __len22, __buffer, __buffer_size);
   std::__merge_adaptive(__new_middle, __second_cut, __last,
    __len1 - __len11,
    __len2 - __len22, __buffer, __buffer_size);
 }
    }


  template<typename _BidirectionalIterator, typename _Distance,
    typename _Pointer, typename _Compare>
    void
    __merge_adaptive(_BidirectionalIterator __first,
                     _BidirectionalIterator __middle,
       _BidirectionalIterator __last,
       _Distance __len1, _Distance __len2,
       _Pointer __buffer, _Distance __buffer_size,
       _Compare __comp)
    {
      if (__len1 <= __len2 && __len1 <= __buffer_size)
 {
   _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
   std::merge((__buffer),
    (__buffer_end),
    (__middle),
    (__last),
    __first, __comp);
 }
      else if (__len2 <= __buffer_size)
 {
   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
   std::__merge_backward((__first),
    (__middle),
    (__buffer),
    (__buffer_end),
    __last,__comp);
 }
      else
 {
   _BidirectionalIterator __first_cut = __first;
   _BidirectionalIterator __second_cut = __middle;
   _Distance __len11 = 0;
   _Distance __len22 = 0;
   if (__len1 > __len2)
     {
       __len11 = __len1 / 2;
       std::advance(__first_cut, __len11);
       __second_cut = std::lower_bound(__middle, __last, *__first_cut,
           __comp);
       __len22 = std::distance(__middle, __second_cut);
     }
   else
     {
       __len22 = __len2 / 2;
       std::advance(__second_cut, __len22);
       __first_cut = std::upper_bound(__first, __middle, *__second_cut,
          __comp);
       __len11 = std::distance(__first, __first_cut);
     }
   _BidirectionalIterator __new_middle =
     std::__rotate_adaptive(__first_cut, __middle, __second_cut,
       __len1 - __len11, __len22, __buffer,
       __buffer_size);
   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
    __len22, __buffer, __buffer_size, __comp);
   std::__merge_adaptive(__new_middle, __second_cut, __last,
    __len1 - __len11,
    __len2 - __len22, __buffer,
    __buffer_size, __comp);
 }
    }


  template<typename _BidirectionalIterator, typename _Distance>
    void
    __merge_without_buffer(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Distance __len1, _Distance __len2)
    {
      if (__len1 == 0 || __len2 == 0)
 return;
      if (__len1 + __len2 == 2)
 {
   if (*__middle < *__first)
     std::iter_swap(__first, __middle);
   return;
 }
      _BidirectionalIterator __first_cut = __first;
      _BidirectionalIterator __second_cut = __middle;
      _Distance __len11 = 0;
      _Distance __len22 = 0;
      if (__len1 > __len2)
 {
   __len11 = __len1 / 2;
   std::advance(__first_cut, __len11);
   __second_cut = std::lower_bound(__middle, __last, *__first_cut);
   __len22 = std::distance(__middle, __second_cut);
 }
      else
 {
   __len22 = __len2 / 2;
   std::advance(__second_cut, __len22);
   __first_cut = std::upper_bound(__first, __middle, *__second_cut);
   __len11 = std::distance(__first, __first_cut);
 }
      std::rotate(__first_cut, __middle, __second_cut);
      _BidirectionalIterator __new_middle = __first_cut;
      std::advance(__new_middle, std::distance(__middle, __second_cut));
      std::__merge_without_buffer(__first, __first_cut, __new_middle,
      __len11, __len22);
      std::__merge_without_buffer(__new_middle, __second_cut, __last,
      __len1 - __len11, __len2 - __len22);
    }


  template<typename _BidirectionalIterator, typename _Distance,
    typename _Compare>
    void
    __merge_without_buffer(_BidirectionalIterator __first,
                           _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Distance __len1, _Distance __len2,
      _Compare __comp)
    {
      if (__len1 == 0 || __len2 == 0)
 return;
      if (__len1 + __len2 == 2)
 {
   if (__comp(*__middle, *__first))
     std::iter_swap(__first, __middle);
   return;
 }
      _BidirectionalIterator __first_cut = __first;
      _BidirectionalIterator __second_cut = __middle;
      _Distance __len11 = 0;
      _Distance __len22 = 0;
      if (__len1 > __len2)
 {
   __len11 = __len1 / 2;
   std::advance(__first_cut, __len11);
   __second_cut = std::lower_bound(__middle, __last, *__first_cut,
       __comp);
   __len22 = std::distance(__middle, __second_cut);
 }
      else
 {
   __len22 = __len2 / 2;
   std::advance(__second_cut, __len22);
   __first_cut = std::upper_bound(__first, __middle, *__second_cut,
      __comp);
   __len11 = std::distance(__first, __first_cut);
 }
      std::rotate(__first_cut, __middle, __second_cut);
      _BidirectionalIterator __new_middle = __first_cut;
      std::advance(__new_middle, std::distance(__middle, __second_cut));
      std::__merge_without_buffer(__first, __first_cut, __new_middle,
      __len11, __len22, __comp);
      std::__merge_without_buffer(__new_middle, __second_cut, __last,
      __len1 - __len11, __len2 - __len22, __comp);
    }
# 3059 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    void
    inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last)
    {
      typedef typename iterator_traits<_BidirectionalIterator>::value_type
          _ValueType;
      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
          _DistanceType;


     

     
      ;
      ;

      if (__first == __middle || __middle == __last)
 return;

      _DistanceType __len1 = std::distance(__first, __middle);
      _DistanceType __len2 = std::distance(__middle, __last);

      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
          __last);
      if (__buf.begin() == 0)
 std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
      else
 std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
         __buf.begin(), _DistanceType(__buf.size()));
    }
# 3114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    void
    inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
    _Compare __comp)
    {
      typedef typename iterator_traits<_BidirectionalIterator>::value_type
          _ValueType;
      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
          _DistanceType;


     

     

      ;
      ;

      if (__first == __middle || __middle == __last)
 return;

      const _DistanceType __len1 = std::distance(__first, __middle);
      const _DistanceType __len2 = std::distance(__middle, __last);

      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
          __last);
      if (__buf.begin() == 0)
 std::__merge_without_buffer(__first, __middle, __last, __len1,
        __len2, __comp);
      else
 std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
         __buf.begin(), _DistanceType(__buf.size()),
         __comp);
    }

  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
    typename _Distance>
    void
    __merge_sort_loop(_RandomAccessIterator1 __first,
        _RandomAccessIterator1 __last,
        _RandomAccessIterator2 __result,
        _Distance __step_size)
    {
      const _Distance __two_step = 2 * __step_size;

      while (__last - __first >= __two_step)
 {
   __result = std::merge(
   (__first),
   (__first + __step_size),
   (__first + __step_size),
   (__first + __two_step),
   __result);
   __first += __two_step;
 }

      __step_size = std::min(_Distance(__last - __first), __step_size);
      std::merge((__first),
       (__first + __step_size)
                   ,
       (__first + __step_size)
                   ,
       (__last),
       __result);
    }

  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
    typename _Distance, typename _Compare>
    void
    __merge_sort_loop(_RandomAccessIterator1 __first,
        _RandomAccessIterator1 __last,
        _RandomAccessIterator2 __result, _Distance __step_size,
        _Compare __comp)
    {
      const _Distance __two_step = 2 * __step_size;

      while (__last - __first >= __two_step)
 {
   __result = std::merge(
   (__first),
   (__first + __step_size),
   (__first + __step_size),
   (__first + __two_step),
   __result, __comp);
   __first += __two_step;
 }
      __step_size = std::min(_Distance(__last - __first), __step_size);

      std::merge((__first),
       (__first + __step_size)
                   ,
       (__first + __step_size)
                   ,
       (__last),
       __result, __comp);
    }

  template<typename _RandomAccessIterator, typename _Distance>
    void
    __chunk_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Distance __chunk_size)
    {
      while (__last - __first >= __chunk_size)
 {
   std::__insertion_sort(__first, __first + __chunk_size);
   __first += __chunk_size;
 }
      std::__insertion_sort(__first, __last);
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Compare>
    void
    __chunk_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Distance __chunk_size, _Compare __comp)
    {
      while (__last - __first >= __chunk_size)
 {
   std::__insertion_sort(__first, __first + __chunk_size, __comp);
   __first += __chunk_size;
 }
      std::__insertion_sort(__first, __last, __comp);
    }

  enum { _S_chunk_size = 7 };

  template<typename _RandomAccessIterator, typename _Pointer>
    void
    __merge_sort_with_buffer(_RandomAccessIterator __first,
        _RandomAccessIterator __last,
                             _Pointer __buffer)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;

      const _Distance __len = __last - __first;
      const _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _S_chunk_size;
      std::__chunk_insertion_sort(__first, __last, __step_size);

      while (__step_size < __len)
 {
   std::__merge_sort_loop(__first, __last, __buffer, __step_size);
   __step_size *= 2;
   std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
   __step_size *= 2;
 }
    }

  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
    void
    __merge_sort_with_buffer(_RandomAccessIterator __first,
        _RandomAccessIterator __last,
                             _Pointer __buffer, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;

      const _Distance __len = __last - __first;
      const _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _S_chunk_size;
      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);

      while (__step_size < __len)
 {
   std::__merge_sort_loop(__first, __last, __buffer,
     __step_size, __comp);
   __step_size *= 2;
   std::__merge_sort_loop(__buffer, __buffer_last, __first,
     __step_size, __comp);
   __step_size *= 2;
 }
    }

  template<typename _RandomAccessIterator, typename _Pointer,
    typename _Distance>
    void
    __stable_sort_adaptive(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
                           _Pointer __buffer, _Distance __buffer_size)
    {
      const _Distance __len = (__last - __first + 1) / 2;
      const _RandomAccessIterator __middle = __first + __len;
      if (__len > __buffer_size)
 {
   std::__stable_sort_adaptive(__first, __middle,
          __buffer, __buffer_size);
   std::__stable_sort_adaptive(__middle, __last,
          __buffer, __buffer_size);
 }
      else
 {
   std::__merge_sort_with_buffer(__first, __middle, __buffer);
   std::__merge_sort_with_buffer(__middle, __last, __buffer);
 }
      std::__merge_adaptive(__first, __middle, __last,
       _Distance(__middle - __first),
       _Distance(__last - __middle),
       __buffer, __buffer_size);
    }

  template<typename _RandomAccessIterator, typename _Pointer,
    typename _Distance, typename _Compare>
    void
    __stable_sort_adaptive(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
                           _Pointer __buffer, _Distance __buffer_size,
                           _Compare __comp)
    {
      const _Distance __len = (__last - __first + 1) / 2;
      const _RandomAccessIterator __middle = __first + __len;
      if (__len > __buffer_size)
 {
   std::__stable_sort_adaptive(__first, __middle, __buffer,
          __buffer_size, __comp);
   std::__stable_sort_adaptive(__middle, __last, __buffer,
          __buffer_size, __comp);
 }
      else
 {
   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
 }
      std::__merge_adaptive(__first, __middle, __last,
       _Distance(__middle - __first),
       _Distance(__last - __middle),
       __buffer, __buffer_size,
       __comp);
    }


  template<typename _RandomAccessIterator>
    void
    __inplace_stable_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last)
    {
      if (__last - __first < 15)
 {
   std::__insertion_sort(__first, __last);
   return;
 }
      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
      std::__inplace_stable_sort(__first, __middle);
      std::__inplace_stable_sort(__middle, __last);
      std::__merge_without_buffer(__first, __middle, __last,
      __middle - __first,
      __last - __middle);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    void
    __inplace_stable_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first < 15)
 {
   std::__insertion_sort(__first, __last, __comp);
   return;
 }
      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
      std::__inplace_stable_sort(__first, __middle, __comp);
      std::__inplace_stable_sort(__middle, __last, __comp);
      std::__merge_without_buffer(__first, __middle, __last,
      __middle - __first,
      __last - __middle,
      __comp);
    }
# 3412 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     
     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first2 < *__first1)
   return false;
 else if(*__first1 < *__first2)
   ++__first1;
 else
   ++__first1, ++__first2;

      return __first2 == __last2;
    }
# 3461 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
    bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first2, *__first1))
   return false;
 else if(__comp(*__first1, *__first2))
   ++__first1;
 else
   ++__first1, ++__first2;

      return __first2 == __last2;
    }
# 3516 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    bool
    next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last)
    {

     

     

      ;

      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (*__i < *__ii)
     {
       _BidirectionalIterator __j = __last;
       while (!(*__i < *--__j))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 3573 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    bool
    next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
    {

     

     


      ;

      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (__comp(*__i, *__ii))
     {
       _BidirectionalIterator __j = __last;
       while (!bool(__comp(*__i, *--__j)))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 3629 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    bool
    prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last)
    {

     

     

      ;

      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (*__ii < *__i)
     {
       _BidirectionalIterator __j = __last;
       while (!(*--__j < *__i))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 3686 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    bool
    prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
    {

     

     


      ;

      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (__comp(*__ii, *__i))
     {
       _BidirectionalIterator __j = __last;
       while (!bool(__comp(*--__j, *__i)))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 3746 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    _OutputIterator
    replace_copy(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result,
   const _Tp& __old_value, const _Tp& __new_value)
    {

     
     

     

      ;

      for (; __first != __last; ++__first, ++__result)
 if (*__first == __old_value)
   *__result = __new_value;
 else
   *__result = *__first;
      return __result;
    }
# 3783 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate, typename _Tp>
    _OutputIterator
    replace_copy_if(_InputIterator __first, _InputIterator __last,
      _OutputIterator __result,
      _Predicate __pred, const _Tp& __new_value)
    {

     
     

     

      ;

      for (; __first != __last; ++__first, ++__result)
 if (__pred(*__first))
   *__result = __new_value;
 else
   *__result = *__first;
      return __result;
    }
# 4161 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
}

namespace std __attribute__ ((__visibility__ ("default"))) {
# 4177 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Function>
    _Function
    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
    {

     
      ;
      for (; __first != __last; ++__first)
 __f(*__first);
      return (__f);
    }
# 4198 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Tp>
    inline _InputIterator
    find(_InputIterator __first, _InputIterator __last,
  const _Tp& __val)
    {

     
     

      ;
      return std::__find(__first, __last, __val,
           std::__iterator_category(__first));
    }
# 4222 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    inline _InputIterator
    find_if(_InputIterator __first, _InputIterator __last,
     _Predicate __pred)
    {

     
     

      ;
      return std::__find_if(__first, __last, __pred,
       std::__iterator_category(__first));
    }
# 4251 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    _InputIterator
    find_first_of(_InputIterator __first1, _InputIterator __last1,
    _ForwardIterator __first2, _ForwardIterator __last2)
    {

     
     
     


      ;
      ;

      for (; __first1 != __last1; ++__first1)
 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
   if (*__first1 == *__iter)
     return __first1;
      return __last1;
    }
# 4290 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
    _InputIterator
    find_first_of(_InputIterator __first1, _InputIterator __last1,
    _ForwardIterator __first2, _ForwardIterator __last2,
    _BinaryPredicate __comp)
    {

     
     
     


      ;
      ;

      for (; __first1 != __last1; ++__first1)
 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
   if (__comp(*__first1, *__iter))
     return __first1;
      return __last1;
    }
# 4322 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    _ForwardIterator
    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;
      if (__first == __last)
 return __last;
      _ForwardIterator __next = __first;
      while(++__next != __last)
 {
   if (*__first == *__next)
     return __first;
   __first = __next;
 }
      return __last;
    }
# 4354 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
    _ForwardIterator
    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
    {

     
     


      ;
      if (__first == __last)
 return __last;
      _ForwardIterator __next = __first;
      while(++__next != __last)
 {
   if (__binary_pred(*__first, *__next))
     return __first;
   __first = __next;
 }
      return __last;
    }
# 4386 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Tp>
    typename iterator_traits<_InputIterator>::difference_type
    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
    {

     
     

      ;
      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      for (; __first != __last; ++__first)
 if (*__first == __value)
   ++__n;
      return __n;
    }
# 4411 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    typename iterator_traits<_InputIterator>::difference_type
    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    {

     
     

      ;
      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      for (; __first != __last; ++__first)
 if (__pred(*__first))
   ++__n;
      return __n;
    }
# 4451 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {

     
     
     


      ;
      ;


      if (__first1 == __last1 || __first2 == __last2)
 return __first1;


      _ForwardIterator2 __p1(__first2);
      if (++__p1 == __last2)
 return std::find(__first1, __last1, *__first2);


      _ForwardIterator2 __p;
      _ForwardIterator1 __current = __first1;

      for (;;)
 {
   __first1 = std::find(__first1, __last1, *__first2);
   if (__first1 == __last1)
     return __last1;

   __p = __p1;
   __current = __first1;
   if (++__current == __last1)
     return __last1;

   while (*__current == *__p)
     {
       if (++__p == __last2)
  return __first1;
       if (++__current == __last1)
  return __last1;
     }
   ++__first1;
 }
      return __first1;
    }
# 4522 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate __predicate)
    {

     
     
     


      ;
      ;


      if (__first1 == __last1 || __first2 == __last2)
 return __first1;


      _ForwardIterator2 __p1(__first2);
      if (++__p1 == __last2)
 {
   while (__first1 != __last1
   && !bool(__predicate(*__first1, *__first2)))
     ++__first1;
   return __first1;
 }


      _ForwardIterator2 __p;
      _ForwardIterator1 __current = __first1;

      for (;;)
 {
   while (__first1 != __last1
   && !bool(__predicate(*__first1, *__first2)))
     ++__first1;
   if (__first1 == __last1)
     return __last1;

   __p = __p1;
   __current = __first1;
   if (++__current == __last1)
     return __last1;

   while (__predicate(*__current, *__p))
     {
       if (++__p == __last2)
  return __first1;
       if (++__current == __last1)
  return __last1;
     }
   ++__first1;
 }
      return __first1;
    }
# 4596 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp>
    _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val)
    {

     
     

      ;

      if (__count <= 0)
 return __first;
      if (__count == 1)
 return std::find(__first, __last, __val);
      return std::__search_n(__first, __last, __count, __val,
        std::__iterator_category(__first));
    }
# 4632 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp,
           typename _BinaryPredicate>
    _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val,
      _BinaryPredicate __binary_pred)
    {

     
     

      ;

      if (__count <= 0)
 return __first;
      if (__count == 1)
 {
   while (__first != __last && !bool(__binary_pred(*__first, __val)))
     ++__first;
   return __first;
 }
      return std::__search_n(__first, __last, __count, __val, __binary_pred,
        std::__iterator_category(__first));
    }
# 4674 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _UnaryOperation>
    _OutputIterator
    transform(_InputIterator __first, _InputIterator __last,
       _OutputIterator __result, _UnaryOperation __unary_op)
    {

     
     


      ;

      for (; __first != __last; ++__first, ++__result)
 *__result = __unary_op(*__first);
      return __result;
    }
# 4710 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _BinaryOperation>
    _OutputIterator
    transform(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _OutputIterator __result,
       _BinaryOperation __binary_op)
    {

     
     
     


      ;

      for (; __first1 != __last1; ++__first1, ++__first2, ++__result)
 *__result = __binary_op(*__first1, *__first2);
      return __result;
    }
# 4743 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    void
    replace(_ForwardIterator __first, _ForwardIterator __last,
     const _Tp& __old_value, const _Tp& __new_value)
    {

     

     

     

      ;

      for (; __first != __last; ++__first)
 if (*__first == __old_value)
   *__first = __new_value;
    }
# 4775 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
    void
    replace_if(_ForwardIterator __first, _ForwardIterator __last,
        _Predicate __pred, const _Tp& __new_value)
    {

     

     

     

      ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   *__first = __new_value;
    }
# 4807 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Generator>
    void
    generate(_ForwardIterator __first, _ForwardIterator __last,
      _Generator __gen)
    {

     
     

      ;

      for (; __first != __last; ++__first)
 *__first = __gen();
    }
# 4838 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _OutputIterator, typename _Size, typename _Generator>
    _OutputIterator
    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
    {

     



      for (; __n > 0; --__n, ++__first)
 *__first = __gen();
      return __first;
    }
# 4874 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result)
    {

     
     

     

      ;

      if (__first == __last)
 return __result;
      return std::__unique_copy(__first, __last, __result,
    std::__iterator_category(__first),
    std::__iterator_category(__result));
    }
# 4913 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result,
  _BinaryPredicate __binary_pred)
    {

     
     

      ;

      if (__first == __last)
 return __result;
      return std::__unique_copy(__first, __last, __result, __binary_pred,
    std::__iterator_category(__first),
    std::__iterator_category(__result));
    }
# 4945 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

      ;

      if (__first != __last)
 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
   std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
    }
# 4973 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
    void
    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,



     _RandomNumberGenerator& __rand)

    {

     

      ;

      if (__first == __last)
 return;
      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 std::iter_swap(__i, __first + __rand((__i - __first) + 1));
    }
# 5009 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    inline _ForwardIterator
    partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      return std::__partition(__first, __last, __pred,
         std::__iterator_category(__first));
    }
# 5043 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      std::__heap_select(__first, __middle, __last);
      std::sort_heap(__first, __middle);
    }
# 5082 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last,
   _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;
      ;

      std::__heap_select(__first, __middle, __last, __comp);
      std::sort_heap(__first, __middle, __comp);
    }
# 5120 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      if (__first == __last || __nth == __last)
 return;

      std::__introselect(__first, __nth, __last,
    std::__lg(__last - __first) * 2);
    }
# 5159 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;
      ;

      if (__first == __last || __nth == __last)
 return;

      std::__introselect(__first, __nth, __last,
    std::__lg(__last - __first) * 2, __comp);
    }
# 5197 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;

      if (__first != __last)
 {
   std::__introsort_loop(__first, __last,
    std::__lg(__last - __first) * 2);
   std::__final_insertion_sort(__first, __last);
 }
    }
# 5233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;

      if (__first != __last)
 {
   std::__introsort_loop(__first, __last,
    std::__lg(__last - __first) * 2, __comp);
   std::__final_insertion_sort(__first, __last, __comp);
 }
    }
# 5274 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 {
   if (*__first2 < *__first1)
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
     }
   ++__result;
 }
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 5337 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(*__first2, *__first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
     }
   ++__result;
 }
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 5397 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;


     

     
      ;

      _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
         __last);
      if (__buf.begin() == 0)
 std::__inplace_stable_sort(__first, __last);
      else
 std::__stable_sort_adaptive(__first, __last, __buf.begin(),
        _DistanceType(__buf.size()));
    }
# 5439 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;


     

     


      ;

      _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
         __last);
      if (__buf.begin() == 0)
 std::__inplace_stable_sort(__first, __last, __comp);
      else
 std::__stable_sort_adaptive(__first, __last, __buf.begin(),
        _DistanceType(__buf.size()), __comp);
    }
# 5485 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     
     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 {
   if (*__first1 < *__first2)
     {
       *__result = *__first1;
       ++__first1;
     }
   else if (*__first2 < *__first1)
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
       ++__first2;
     }
   ++__result;
 }
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 5552 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(*__first1, *__first2))
     {
       *__result = *__first1;
       ++__first1;
     }
   else if (__comp(*__first2, *__first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
       ++__first2;
     }
   ++__result;
 }
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 5619 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     
     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first1 < *__first2)
   ++__first1;
 else if (*__first2 < *__first1)
   ++__first2;
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
     ++__result;
   }
      return __result;
    }
# 5676 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first1, *__first2))
   ++__first1;
 else if (__comp(*__first2, *__first1))
   ++__first2;
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
     ++__result;
   }
      return __result;
    }
# 5734 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     
     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first1 < *__first2)
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (*__first2 < *__first1)
   ++__first2;
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first1, __last1, __result);
    }
# 5795 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first1, *__first2))
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (__comp(*__first2, *__first1))
   ++__first2;
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first1, __last1, __result);
    }
# 5853 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     
     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first1 < *__first2)
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (*__first2 < *__first1)
   {
     *__result = *__first2;
     ++__first2;
     ++__result;
   }
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first2, __last2, std::copy(__first1,
          __last1, __result));
    }
# 5919 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result,
        _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first1, *__first2))
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (__comp(*__first2, *__first1))
   {
     *__result = *__first2;
     ++__first2;
     ++__result;
   }
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first2, __last2,
         std::copy(__first1, __last1, __result));
    }
# 5976 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    _ForwardIterator
    min_element(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;

      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (*__first < *__result)
   __result = __first;
      return __result;
    }
# 6004 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    _ForwardIterator
    min_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {

     
     


      ;

      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(*__first, *__result))
   __result = __first;
      return __result;
    }
# 6032 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;

      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (*__result < *__first)
   __result = __first;
      return __result;
    }
# 6060 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {

     
     


      ;

      if (__first == __last) return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(*__result, *__first))
   __result = __first;
      return __result;
    }

}
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/algorithm" 2 3
# 14 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
# 1 "/usr/include/boost-1_42/boost/config/no_tr1/functional.hpp" 1
# 21 "/usr/include/boost-1_42/boost/config/no_tr1/functional.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/functional" 1 3
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/functional" 3
       
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/functional" 3
# 22 "/usr/include/boost-1_42/boost/config/no_tr1/functional.hpp" 2
# 15 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
# 1 "/usr/include/boost-1_42/boost/throw_exception.hpp" 1
# 23 "/usr/include/boost-1_42/boost/throw_exception.hpp"
# 1 "/usr/include/boost-1_42/boost/exception/detail/attribute_noreturn.hpp" 1
# 24 "/usr/include/boost-1_42/boost/throw_exception.hpp" 2
# 37 "/usr/include/boost-1_42/boost/throw_exception.hpp"
# 1 "/usr/include/boost-1_42/boost/exception/exception.hpp" 1
# 9 "/usr/include/boost-1_42/boost/exception/exception.hpp"
       
# 10 "/usr/include/boost-1_42/boost/exception/exception.hpp" 3





namespace
boost
    {
    namespace
    exception_detail
        {
        template <class T>
        class
        refcount_ptr
            {
            public:

            refcount_ptr():
                px_(0)
                {
                }

            ~refcount_ptr()
                {
                release();
                }

            refcount_ptr( refcount_ptr const & x ):
                px_(x.px_)
                {
                add_ref();
                }

            refcount_ptr &
            operator=( refcount_ptr const & x )
                {
                adopt(x.px_);
                return *this;
                }

            void
            adopt( T * px )
                {
                release();
                px_=px;
                add_ref();
                }

            T *
            get() const
                {
                return px_;
                }

            private:

            T * px_;

            void
            add_ref()
                {
                if( px_ )
                    px_->add_ref();
                }

            void
            release()
                {
                if( px_ )
                    px_->release();
                }
            };
        }



    template <class Tag,class T>
    class error_info;

    typedef error_info<struct throw_function_,char const *> throw_function;
    typedef error_info<struct throw_file_,char const *> throw_file;
    typedef error_info<struct throw_line_,int> throw_line;

    template <>
    class
    error_info<throw_function_,char const *>
        {
        public:
        typedef char const * value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_file_,char const *>
        {
        public:
        typedef char const * value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_line_,int>
        {
        public:
        typedef int value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <class E,class Tag,class T>
    E const & operator<<( E const &, error_info<Tag,T> const & );

    template <class E>
    E const & operator<<( E const &, throw_function const & );

    template <class E>
    E const & operator<<( E const &, throw_file const & );

    template <class E>
    E const & operator<<( E const &, throw_line const & );

    class exception;

    template <class>
    class shared_ptr;

    namespace
    exception_detail
        {
        class error_info_base;
        struct type_info_;

        struct
        error_info_container
            {
            virtual char const * diagnostic_information( char const * ) const = 0;
            virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
            virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
            virtual void add_ref() const = 0;
            virtual void release() const = 0;

            protected:

            ~error_info_container() throw()
                {
                }
            };

        template <class>
        struct get_info;

        template <>
        struct get_info<throw_function>;

        template <>
        struct get_info<throw_file>;

        template <>
        struct get_info<throw_line>;

        char const * get_diagnostic_information( exception const &, char const * );
        }

    class
    exception
        {
        protected:

        exception():
            throw_function_(0),
            throw_file_(0),
            throw_line_(-1)
            {
            }
# 213 "/usr/include/boost-1_42/boost/exception/exception.hpp" 3
        virtual ~exception() throw()

            = 0

            ;




        private:

        template <class E>
        friend E const & operator<<( E const &, throw_function const & );

        template <class E>
        friend E const & operator<<( E const &, throw_file const & );

        template <class E>
        friend E const & operator<<( E const &, throw_line const & );

        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );

        template <class E,class Tag,class T>
        friend E const & operator<<( E const &, error_info<Tag,T> const & );

        template <class>
        friend struct exception_detail::get_info;
        friend struct exception_detail::get_info<throw_function>;
        friend struct exception_detail::get_info<throw_file>;
        friend struct exception_detail::get_info<throw_line>;

        mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
        mutable char const * throw_function_;
        mutable char const * throw_file_;
        mutable int throw_line_;
        };

    inline
    exception::
    ~exception() throw()
        {
        }

    template <class E>
    E const &
    operator<<( E const & x, throw_function const & y )
        {
        x.throw_function_=y.v_;
        return x;
        }

    template <class E>
    E const &
    operator<<( E const & x, throw_file const & y )
        {
        x.throw_file_=y.v_;
        return x;
        }

    template <class E>
    E const &
    operator<<( E const & x, throw_line const & y )
        {
        x.throw_line_=y.v_;
        return x;
        }



    namespace
    exception_detail
        {
        template <class T>
        struct
        error_info_injector:
            public T,
            public exception
            {
            explicit
            error_info_injector( T const & x ):
                T(x)
                {
                }

            ~error_info_injector() throw()
                {
                }
            };

        struct large_size { char c[256]; };
        large_size dispatch( exception * );

        struct small_size { };
        small_size dispatch( void * );

        template <class,int>
        struct enable_error_info_helper;

        template <class T>
        struct
        enable_error_info_helper<T,sizeof(large_size)>
            {
            typedef T type;
            };

        template <class T>
        struct
        enable_error_info_helper<T,sizeof(small_size)>
            {
            typedef error_info_injector<T> type;
            };

        template <class T>
        struct
        enable_error_info_return_type
            {
            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch((T*)0))>::type type;
            };
        }

    template <class T>
    inline
    typename
    exception_detail::enable_error_info_return_type<T>::type
    enable_error_info( T const & x )
        {
        typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
        return rt(x);
        }



    namespace
    exception_detail
        {
        class
        clone_base
            {
            public:

            virtual clone_base const * clone() const = 0;
            virtual void rethrow() const = 0;

            virtual
            ~clone_base() throw()
                {
                }
            };

        inline
        void
        copy_boost_exception( exception * a, exception const * b )
            {
            *a = *b;
            }

        inline
        void
        copy_boost_exception( void *, void const * )
            {
            }

        template <class T>
        class
        clone_impl:
            public T,
            public clone_base
            {
            public:

            explicit
            clone_impl( T const & x ):
                T(x)
                {
                copy_boost_exception(this,&x);
                }

            ~clone_impl() throw()
                {
                }

            private:

            clone_base const *
            clone() const
                {
                return new clone_impl(*this);
                }

            void
            rethrow() const
                {
                throw*this;
                }
            };
        }

    template <class T>
    inline
    exception_detail::clone_impl<T>
    enable_current_exception( T const & x )
        {
        return exception_detail::clone_impl<T>(x);
        }
    }
# 38 "/usr/include/boost-1_42/boost/throw_exception.hpp" 2
# 1 "/usr/include/boost-1_42/boost/current_function.hpp" 1
# 22 "/usr/include/boost-1_42/boost/current_function.hpp"
namespace boost
{

namespace detail
{

inline void current_function_helper()
{
# 61 "/usr/include/boost-1_42/boost/current_function.hpp"
}

}

}
# 39 "/usr/include/boost-1_42/boost/throw_exception.hpp" 2
# 47 "/usr/include/boost-1_42/boost/throw_exception.hpp"
namespace boost
{







inline void throw_exception_assert_compatibility( std::exception const & ) { }

template<class E> __attribute__((noreturn)) inline void throw_exception( E const & e )
{


    throw_exception_assert_compatibility(e);


    throw enable_current_exception(enable_error_info(e));



}



}
# 16 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2

# 1 "/usr/include/boost-1_42/boost/function/function_base.hpp" 1
# 14 "/usr/include/boost-1_42/boost/function/function_base.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/stdexcept" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/stdexcept" 3
       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/stdexcept" 3




namespace std __attribute__ ((__visibility__ ("default"))) {
# 53 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/stdexcept" 3
  class logic_error : public exception
  {
    string _M_msg;

  public:

    explicit
    logic_error(const string& __arg);

    virtual
    ~logic_error() throw();



    virtual const char*
    what() const throw();
  };



  class domain_error : public logic_error
  {
  public:
    explicit domain_error(const string& __arg);
  };


  class invalid_argument : public logic_error
  {
  public:
    explicit invalid_argument(const string& __arg);
  };



  class length_error : public logic_error
  {
  public:
    explicit length_error(const string& __arg);
  };



  class out_of_range : public logic_error
  {
  public:
    explicit out_of_range(const string& __arg);
  };






  class runtime_error : public exception
  {
    string _M_msg;

  public:

    explicit
    runtime_error(const string& __arg);

    virtual
    ~runtime_error() throw();



    virtual const char*
    what() const throw();
  };


  class range_error : public runtime_error
  {
  public:
    explicit range_error(const string& __arg);
  };


  class overflow_error : public runtime_error
  {
  public:
    explicit overflow_error(const string& __arg);
  };


  class underflow_error : public runtime_error
  {
  public:
    explicit underflow_error(const string& __arg);
  };



}
# 15 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 1 3
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 3
       
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 3
# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_raw_storage_iter.h" 1 3
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_raw_storage_iter.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {





  template <class _OutputIterator, class _Tp>
    class raw_storage_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _OutputIterator _M_iter;

    public:
      explicit
      raw_storage_iterator(_OutputIterator __x)
      : _M_iter(__x) {}

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

      raw_storage_iterator&
      operator=(const _Tp& __element)
      {
 std::_Construct(&*_M_iter, __element);
 return *this;
      }

      raw_storage_iterator<_OutputIterator, _Tp>&
      operator++()
      {
 ++_M_iter;
 return *this;
      }

      raw_storage_iterator<_OutputIterator, _Tp>
      operator++(int)
      {
 raw_storage_iterator<_OutputIterator, _Tp> __tmp = *this;
 ++_M_iter;
 return __tmp;
      }
    };

}
# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 2 3
# 103 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
  template<typename _Tp1>
    struct auto_ptr_ref
    {
      _Tp1* _M_ptr;

      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
    } ;
# 84 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
  template<typename _Tp>
    class auto_ptr
    {
    private:
      _Tp* _M_ptr;

    public:

      typedef _Tp element_type;







      explicit
      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
# 110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
# 122 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
 reset(__a.release());
 return *this;
      }
# 150 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr&
        operator=(auto_ptr<_Tp1>& __a) throw()
        {
   reset(__a.release());
   return *this;
 }
# 168 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
      ~auto_ptr() { delete _M_ptr; }
# 178 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
      element_type&
      operator*() const throw()
      {
 ;
 return *_M_ptr;
      }







      element_type*
      operator->() const throw()
      {
 ;
 return _M_ptr;
      }
# 208 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
      element_type*
      get() const throw() { return _M_ptr; }
# 222 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
      element_type*
      release() throw()
      {
 element_type* __tmp = _M_ptr;
 _M_ptr = 0;
 return __tmp;
      }
# 237 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
      void
      reset(element_type* __p = 0) throw()
      {
 if (__p != _M_ptr)
   {
     delete _M_ptr;
     _M_ptr = __p;
   }
      }
# 258 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
      : _M_ptr(__ref._M_ptr) { }

      auto_ptr&
      operator=(auto_ptr_ref<element_type> __ref) throw()
      {
 if (__ref._M_ptr != this->get())
   {
     delete _M_ptr;
     _M_ptr = __ref._M_ptr;
   }
 return *this;
      }

      template<typename _Tp1>
        operator auto_ptr_ref<_Tp1>() throw()
        { return auto_ptr_ref<_Tp1>(this->release()); }

      template<typename _Tp1>
        operator auto_ptr<_Tp1>() throw()
        { return auto_ptr<_Tp1>(this->release()); }
    } ;



  template<>
    class auto_ptr<void>
    {
    public:
      typedef void element_type;
    } ;

}
# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 2 3
# 17 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2


# 1 "/usr/include/boost-1_42/boost/detail/sp_typeinfo.hpp" 1
# 103 "/usr/include/boost-1_42/boost/detail/sp_typeinfo.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 3
       
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 3



#pragma GCC visibility push(default)

extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}
# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 3
namespace std
{






  class type_info
  {
  public:




    virtual ~type_info();



    const char* name() const
    { return __name[0] == '*' ? __name + 1 : __name; }
# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 3
    bool before(const type_info& __arg) const
    { return (__name[0] == '*' && __arg.__name[0] == '*')
 ? __name < __arg.__name
 : __builtin_strcmp (__name, __arg.__name) < 0; }

    bool operator==(const type_info& __arg) const
    {
      return ((__name == __arg.__name)
       || (__name[0] != '*' &&
    __builtin_strcmp (__name, __arg.__name) == 0));
    }
# 135 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 3
    bool operator!=(const type_info& __arg) const
    { return !operator==(__arg); }


    virtual bool __is_pointer_p() const;


    virtual bool __is_function_p() const;







    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
       unsigned __outer) const;


    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
        void **__obj_ptr) const;

  protected:
    const char *__name;

    explicit type_info(const char *__n): __name(__n) { }

  private:

    type_info& operator=(const type_info&);
    type_info(const type_info&);
  };







  class bad_cast : public exception
  {
  public:
    bad_cast() throw() { }



    virtual ~bad_cast() throw();


    virtual const char* what() const throw();
  };





  class bad_typeid : public exception
  {
  public:
    bad_typeid () throw() { }



    virtual ~bad_typeid() throw();


    virtual const char* what() const throw();
  };
}

#pragma GCC visibility pop

}
# 104 "/usr/include/boost-1_42/boost/detail/sp_typeinfo.hpp" 2

namespace boost
{

namespace detail
{







typedef std::type_info sp_typeinfo;



}

}
# 20 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
# 1 "/usr/include/boost-1_42/boost/assert.hpp" 1
# 36 "/usr/include/boost-1_42/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 37 "/usr/include/boost-1_42/boost/assert.hpp" 2
# 21 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
# 1 "/usr/include/boost-1_42/boost/integer.hpp" 1
# 18 "/usr/include/boost-1_42/boost/integer.hpp"
# 1 "/usr/include/boost-1_42/boost/integer_fwd.hpp" 1
# 12 "/usr/include/boost-1_42/boost/integer_fwd.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 2 3
# 13 "/usr/include/boost-1_42/boost/integer_fwd.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 14 "/usr/include/boost-1_42/boost/integer_fwd.hpp" 2


# 1 "/usr/include/boost-1_42/boost/limits.hpp" 1
# 19 "/usr/include/boost-1_42/boost/limits.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
# 148 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
namespace std __attribute__ ((__visibility__ ("default"))) {






  enum float_round_style
  {
    round_indeterminate = -1,
    round_toward_zero = 0,
    round_to_nearest = 1,
    round_toward_infinity = 2,
    round_toward_neg_infinity = 3
  };







  enum float_denorm_style
  {

    denorm_indeterminate = -1,

    denorm_absent = 0,

    denorm_present = 1
  };
# 190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
  struct __numeric_limits_base
  {


    static const bool is_specialized = false;




    static const int digits = 0;

    static const int digits10 = 0;






    static const bool is_signed = false;


    static const bool is_integer = false;




    static const bool is_exact = false;


    static const int radix = 0;



    static const int min_exponent = 0;


    static const int min_exponent10 = 0;



    static const int max_exponent = 0;


    static const int max_exponent10 = 0;


    static const bool has_infinity = false;


    static const bool has_quiet_NaN = false;


    static const bool has_signaling_NaN = false;

    static const float_denorm_style has_denorm = denorm_absent;


    static const bool has_denorm_loss = false;



    static const bool is_iec559 = false;



    static const bool is_bounded = false;




    static const bool is_modulo = false;


    static const bool traps = false;

    static const bool tinyness_before = false;



    static const float_round_style round_style = round_toward_zero;
  };
# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
  template<typename _Tp>
    struct numeric_limits : public __numeric_limits_base
    {


      static _Tp min() throw() { return static_cast<_Tp>(0); }

      static _Tp max() throw() { return static_cast<_Tp>(0); }







      static _Tp epsilon() throw() { return static_cast<_Tp>(0); }

      static _Tp round_error() throw() { return static_cast<_Tp>(0); }

      static _Tp infinity() throw() { return static_cast<_Tp>(0); }



      static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }


      static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }



      static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }
    };
# 334 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
  template<>
    struct numeric_limits<bool>
    {
      static const bool is_specialized = true;

      static bool min() throw()
      { return false; }
      static bool max() throw()
      { return true; }




      static const int digits = 1;
      static const int digits10 = 0;



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static bool epsilon() throw()
      { return false; }
      static bool round_error() throw()
      { return false; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static bool infinity() throw()
      { return false; }
      static bool quiet_NaN() throw()
      { return false; }
      static bool signaling_NaN() throw()
      { return false; }
      static bool denorm_min() throw()
      { return false; }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = false;




      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<char>
    {
      static const bool is_specialized = true;

      static char min() throw()
      { return (((char)(-1) < 0) ? (char)1 << (sizeof(char) * 8 - ((char)(-1) < 0)) : (char)0); }
      static char max() throw()
      { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }





      static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
      static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = ((char)(-1) < 0);
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static char epsilon() throw()
      { return 0; }
      static char round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static char infinity() throw()
      { return char(); }
      static char quiet_NaN() throw()
      { return char(); }
      static char signaling_NaN() throw()
      { return char(); }
      static char denorm_min() throw()
      { return static_cast<char>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<signed char>
    {
      static const bool is_specialized = true;

      static signed char min() throw()
      { return -127 - 1; }
      static signed char max() throw()
      { return 127; }





      static const int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
      static const int digits10 = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static signed char epsilon() throw()
      { return 0; }
      static signed char round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static signed char infinity() throw()
      { return static_cast<signed char>(0); }
      static signed char quiet_NaN() throw()
      { return static_cast<signed char>(0); }
      static signed char signaling_NaN() throw()
      { return static_cast<signed char>(0); }
      static signed char denorm_min() throw()
      { return static_cast<signed char>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned char>
    {
      static const bool is_specialized = true;

      static unsigned char min() throw()
      { return 0; }
      static unsigned char max() throw()
      { return 127 * 2U + 1; }





      static const int digits = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static unsigned char epsilon() throw()
      { return 0; }
      static unsigned char round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static unsigned char infinity() throw()
      { return static_cast<unsigned char>(0); }
      static unsigned char quiet_NaN() throw()
      { return static_cast<unsigned char>(0); }
      static unsigned char signaling_NaN() throw()
      { return static_cast<unsigned char>(0); }
      static unsigned char denorm_min() throw()
      { return static_cast<unsigned char>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<wchar_t>
    {
      static const bool is_specialized = true;

      static wchar_t min() throw()
      { return (((wchar_t)(-1) < 0) ? (wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) : (wchar_t)0); }
      static wchar_t max() throw()
      { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }





      static const int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
      static const int digits10 = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = ((wchar_t)(-1) < 0);
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static wchar_t epsilon() throw()
      { return 0; }
      static wchar_t round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static wchar_t infinity() throw()
      { return wchar_t(); }
      static wchar_t quiet_NaN() throw()
      { return wchar_t(); }
      static wchar_t signaling_NaN() throw()
      { return wchar_t(); }
      static wchar_t denorm_min() throw()
      { return wchar_t(); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };
# 744 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
  template<>
    struct numeric_limits<short>
    {
      static const bool is_specialized = true;

      static short min() throw()
      { return -32767 - 1; }
      static short max() throw()
      { return 32767; }





      static const int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
      static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static short epsilon() throw()
      { return 0; }
      static short round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static short infinity() throw()
      { return short(); }
      static short quiet_NaN() throw()
      { return short(); }
      static short signaling_NaN() throw()
      { return short(); }
      static short denorm_min() throw()
      { return short(); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned short>
    {
      static const bool is_specialized = true;

      static unsigned short min() throw()
      { return 0; }
      static unsigned short max() throw()
      { return 32767 * 2U + 1; }





      static const int digits = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static unsigned short epsilon() throw()
      { return 0; }
      static unsigned short round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static unsigned short infinity() throw()
      { return static_cast<unsigned short>(0); }
      static unsigned short quiet_NaN() throw()
      { return static_cast<unsigned short>(0); }
      static unsigned short signaling_NaN() throw()
      { return static_cast<unsigned short>(0); }
      static unsigned short denorm_min() throw()
      { return static_cast<unsigned short>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<int>
    {
      static const bool is_specialized = true;

      static int min() throw()
      { return -2147483647 - 1; }
      static int max() throw()
      { return 2147483647; }





      static const int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
      static const int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static int epsilon() throw()
      { return 0; }
      static int round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static int infinity() throw()
      { return static_cast<int>(0); }
      static int quiet_NaN() throw()
      { return static_cast<int>(0); }
      static int signaling_NaN() throw()
      { return static_cast<int>(0); }
      static int denorm_min() throw()
      { return static_cast<int>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned int>
    {
      static const bool is_specialized = true;

      static unsigned int min() throw()
      { return 0; }
      static unsigned int max() throw()
      { return 2147483647 * 2U + 1; }





      static const int digits = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static unsigned int epsilon() throw()
      { return 0; }
      static unsigned int round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static unsigned int infinity() throw()
      { return static_cast<unsigned int>(0); }
      static unsigned int quiet_NaN() throw()
      { return static_cast<unsigned int>(0); }
      static unsigned int signaling_NaN() throw()
      { return static_cast<unsigned int>(0); }
      static unsigned int denorm_min() throw()
      { return static_cast<unsigned int>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<long>
    {
      static const bool is_specialized = true;

      static long min() throw()
      { return -9223372036854775807L - 1; }
      static long max() throw()
      { return 9223372036854775807L; }





      static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
      static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static long epsilon() throw()
      { return 0; }
      static long round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static long infinity() throw()
      { return static_cast<long>(0); }
      static long quiet_NaN() throw()
      { return static_cast<long>(0); }
      static long signaling_NaN() throw()
      { return static_cast<long>(0); }
      static long denorm_min() throw()
      { return static_cast<long>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned long>
    {
      static const bool is_specialized = true;

      static unsigned long min() throw()
      { return 0; }
      static unsigned long max() throw()
      { return 9223372036854775807L * 2UL + 1; }





      static const int digits = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static unsigned long epsilon() throw()
      { return 0; }
      static unsigned long round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static unsigned long infinity() throw()
      { return static_cast<unsigned long>(0); }
      static unsigned long quiet_NaN() throw()
      { return static_cast<unsigned long>(0); }
      static unsigned long signaling_NaN() throw()
      { return static_cast<unsigned long>(0); }
      static unsigned long denorm_min() throw()
      { return static_cast<unsigned long>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<long long>
    {
      static const bool is_specialized = true;

      static long long min() throw()
      { return -9223372036854775807LL - 1; }
      static long long max() throw()
      { return 9223372036854775807LL; }





      static const int digits = (sizeof(long long) * 8 - ((long long)(-1) < 0));
      static const int digits10 = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static long long epsilon() throw()
      { return 0; }
      static long long round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static long long infinity() throw()
      { return static_cast<long long>(0); }
      static long long quiet_NaN() throw()
      { return static_cast<long long>(0); }
      static long long signaling_NaN() throw()
      { return static_cast<long long>(0); }
      static long long denorm_min() throw()
      { return static_cast<long long>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned long long>
    {
      static const bool is_specialized = true;

      static unsigned long long min() throw()
      { return 0; }
      static unsigned long long max() throw()
      { return 9223372036854775807LL * 2ULL + 1; }





      static const int digits = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643 / 2136);



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static unsigned long long epsilon() throw()
      { return 0; }
      static unsigned long long round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static unsigned long long infinity() throw()
      { return static_cast<unsigned long long>(0); }
      static unsigned long long quiet_NaN() throw()
      { return static_cast<unsigned long long>(0); }
      static unsigned long long signaling_NaN() throw()
      { return static_cast<unsigned long long>(0); }
      static unsigned long long denorm_min() throw()
      { return static_cast<unsigned long long>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<float>
    {
      static const bool is_specialized = true;

      static float min() throw()
      { return 1.17549435082228750797e-38F; }
      static float max() throw()
      { return 3.40282346638528859812e+38F; }





      static const int digits = 24;
      static const int digits10 = 6;




      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 2;
      static float epsilon() throw()
      { return 1.19209289550781250000e-7F; }
      static float round_error() throw()
      { return 0.5F; }

      static const int min_exponent = (-125);
      static const int min_exponent10 = (-37);
      static const int max_exponent = 128;
      static const int max_exponent10 = 38;

      static const bool has_infinity = 1;
      static const bool has_quiet_NaN = 1;
      static const bool has_signaling_NaN = has_quiet_NaN;
      static const float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static const bool has_denorm_loss = false;

      static float infinity() throw()
      { return __builtin_huge_valf (); }
      static float quiet_NaN() throw()
      { return __builtin_nanf (""); }
      static float signaling_NaN() throw()
      { return __builtin_nansf (""); }
      static float denorm_min() throw()
      { return 1.40129846432481707092e-45F; }

      static const bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_to_nearest;
    };






  template<>
    struct numeric_limits<double>
    {
      static const bool is_specialized = true;

      static double min() throw()
      { return ((double)2.22507385850720138309e-308L); }
      static double max() throw()
      { return ((double)1.79769313486231570815e+308L); }





      static const int digits = 53;
      static const int digits10 = 15;




      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 2;
      static double epsilon() throw()
      { return ((double)2.22044604925031308085e-16L); }
      static double round_error() throw()
      { return 0.5; }

      static const int min_exponent = (-1021);
      static const int min_exponent10 = (-307);
      static const int max_exponent = 1024;
      static const int max_exponent10 = 308;

      static const bool has_infinity = 1;
      static const bool has_quiet_NaN = 1;
      static const bool has_signaling_NaN = has_quiet_NaN;
      static const float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static const bool has_denorm_loss = false;

      static double infinity() throw()
      { return __builtin_huge_val(); }
      static double quiet_NaN() throw()
      { return __builtin_nan (""); }
      static double signaling_NaN() throw()
      { return __builtin_nans (""); }
      static double denorm_min() throw()
      { return ((double)4.94065645841246544177e-324L); }

      static const bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_to_nearest;
    };






  template<>
    struct numeric_limits<long double>
    {
      static const bool is_specialized = true;

      static long double min() throw()
      { return 3.36210314311209350626e-4932L; }
      static long double max() throw()
      { return 1.18973149535723176502e+4932L; }





      static const int digits = 64;
      static const int digits10 = 18;




      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 2;
      static long double epsilon() throw()
      { return 1.08420217248550443401e-19L; }
      static long double round_error() throw()
      { return 0.5L; }

      static const int min_exponent = (-16381);
      static const int min_exponent10 = (-4931);
      static const int max_exponent = 16384;
      static const int max_exponent10 = 4932;

      static const bool has_infinity = 1;
      static const bool has_quiet_NaN = 1;
      static const bool has_signaling_NaN = has_quiet_NaN;
      static const float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static const bool has_denorm_loss
 = false;

      static long double infinity() throw()
      { return __builtin_huge_vall (); }
      static long double quiet_NaN() throw()
      { return __builtin_nanl (""); }
      static long double signaling_NaN() throw()
      { return __builtin_nansl (""); }
      static long double denorm_min() throw()
      { return 3.64519953188247460253e-4951L; }

      static const bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_to_nearest;
    };





}
# 20 "/usr/include/boost-1_42/boost/limits.hpp" 2
# 17 "/usr/include/boost-1_42/boost/integer_fwd.hpp" 2
# 1 "/usr/include/boost-1_42/boost/cstdint.hpp" 1
# 100 "/usr/include/boost-1_42/boost/cstdint.hpp"
namespace boost
{

  using ::int8_t;
  using ::int_least8_t;
  using ::int_fast8_t;
  using ::uint8_t;
  using ::uint_least8_t;
  using ::uint_fast8_t;

  using ::int16_t;
  using ::int_least16_t;
  using ::int_fast16_t;
  using ::uint16_t;
  using ::uint_least16_t;
  using ::uint_fast16_t;

  using ::int32_t;
  using ::int_least32_t;
  using ::int_fast32_t;
  using ::uint32_t;
  using ::uint_least32_t;
  using ::uint_fast32_t;



  using ::int64_t;
  using ::int_least64_t;
  using ::int_fast64_t;
  using ::uint64_t;
  using ::uint_least64_t;
  using ::uint_fast64_t;



  using ::intmax_t;
  using ::uintmax_t;

}
# 370 "/usr/include/boost-1_42/boost/cstdint.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
# 371 "/usr/include/boost-1_42/boost/cstdint.hpp" 2
# 18 "/usr/include/boost-1_42/boost/integer_fwd.hpp" 2


namespace boost
{







     typedef boost::uintmax_t static_min_max_unsigned_type;
     typedef boost::intmax_t static_min_max_signed_type;
     typedef boost::uintmax_t static_log2_argument_type;
     typedef int static_log2_result_type;
# 42 "/usr/include/boost-1_42/boost/integer_fwd.hpp"
template < class T >
    class integer_traits;

template < >
    class integer_traits< bool >;

template < >
    class integer_traits< char >;

template < >
    class integer_traits< signed char >;

template < >
    class integer_traits< unsigned char >;


template < >
    class integer_traits< wchar_t >;


template < >
    class integer_traits< short >;

template < >
    class integer_traits< unsigned short >;

template < >
    class integer_traits< int >;

template < >
    class integer_traits< unsigned int >;

template < >
    class integer_traits< long >;

template < >
    class integer_traits< unsigned long >;


template < >
    class integer_traits< ::boost::long_long_type>;

template < >
    class integer_traits< ::boost::ulong_long_type >;





template < typename LeastInt >
    struct int_fast_t;

template< int Bits >
    struct int_t;

template< int Bits >
    struct uint_t;


    template< boost::long_long_type MaxValue >



    struct int_max_value_t;


  template< boost::long_long_type MinValue >



    struct int_min_value_t;


  template< boost::ulong_long_type MaxValue >



    struct uint_value_t;




template < std::size_t Bit >
    struct high_bit_mask_t;

template < std::size_t Bits >
    struct low_bits_mask_t;

template < >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;


template < >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned short>::digits >;



template < >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned int>::digits >;



template < >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned long>::digits >;





template <static_log2_argument_type Value >
    struct static_log2;

template <> struct static_log2<0u>;




template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
    struct static_signed_min;

template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
    struct static_signed_max;

template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
    struct static_unsigned_min;

template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
    struct static_unsigned_max;

}
# 19 "/usr/include/boost-1_42/boost/integer.hpp" 2

# 1 "/usr/include/boost-1_42/boost/integer_traits.hpp" 1
# 23 "/usr/include/boost-1_42/boost/integer_traits.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
# 24 "/usr/include/boost-1_42/boost/integer_traits.hpp" 2



# 1 "/usr/include/wchar.h" 1 3 4
# 28 "/usr/include/boost-1_42/boost/integer_traits.hpp" 2
# 39 "/usr/include/boost-1_42/boost/integer_traits.hpp"
       
# 40 "/usr/include/boost-1_42/boost/integer_traits.hpp" 3


namespace boost {
template<class T>
class integer_traits : public std::numeric_limits<T>
{
public:
  static const bool is_integral = false;
};

namespace detail {
template<class T, T min_val, T max_val>
class integer_traits_base
{
public:
  static const bool is_integral = true;
  static const T const_min = min_val;
  static const T const_max = max_val;
};



template<class T, T min_val, T max_val>
const bool integer_traits_base<T, min_val, max_val>::is_integral;

template<class T, T min_val, T max_val>
const T integer_traits_base<T, min_val, max_val>::const_min;

template<class T, T min_val, T max_val>
const T integer_traits_base<T, min_val, max_val>::const_max;


}

template<>
class integer_traits<bool>
  : public std::numeric_limits<bool>,
    public detail::integer_traits_base<bool, false, true>
{ };

template<>
class integer_traits<char>
  : public std::numeric_limits<char>,
    public detail::integer_traits_base<char, (-127 - 1), 127>
{ };

template<>
class integer_traits<signed char>
  : public std::numeric_limits<signed char>,
    public detail::integer_traits_base<signed char, (-127 - 1), 127>
{ };

template<>
class integer_traits<unsigned char>
  : public std::numeric_limits<unsigned char>,
    public detail::integer_traits_base<unsigned char, 0, (127 * 2 + 1)>
{ };


template<>
class integer_traits<wchar_t>
  : public std::numeric_limits<wchar_t>,



    public detail::integer_traits_base<wchar_t, (-2147483647 - 1), (2147483647)>
# 130 "/usr/include/boost-1_42/boost/integer_traits.hpp" 3
{ };


template<>
class integer_traits<short>
  : public std::numeric_limits<short>,
    public detail::integer_traits_base<short, (-32767 - 1), 32767>
{ };

template<>
class integer_traits<unsigned short>
  : public std::numeric_limits<unsigned short>,
    public detail::integer_traits_base<unsigned short, 0, (32767 * 2 + 1)>
{ };

template<>
class integer_traits<int>
  : public std::numeric_limits<int>,
    public detail::integer_traits_base<int, (-2147483647 - 1), 2147483647>
{ };

template<>
class integer_traits<unsigned int>
  : public std::numeric_limits<unsigned int>,
    public detail::integer_traits_base<unsigned int, 0, (2147483647 * 2U + 1U)>
{ };

template<>
class integer_traits<long>
  : public std::numeric_limits<long>,
    public detail::integer_traits_base<long, (-9223372036854775807L - 1L), 9223372036854775807L>
{ };

template<>
class integer_traits<unsigned long>
  : public std::numeric_limits<unsigned long>,
    public detail::integer_traits_base<unsigned long, 0, (9223372036854775807L * 2UL + 1UL)>
{ };




template<>
class integer_traits< ::boost::long_long_type>
  : public std::numeric_limits< ::boost::long_long_type>,
    public detail::integer_traits_base< ::boost::long_long_type, (-9223372036854775807LL -1), 9223372036854775807LL>
{ };

template<>
class integer_traits< ::boost::ulong_long_type>
  : public std::numeric_limits< ::boost::ulong_long_type>,
    public detail::integer_traits_base< ::boost::ulong_long_type, 0, (9223372036854775807LL * 2ULL + 1)>
{ };
# 256 "/usr/include/boost-1_42/boost/integer_traits.hpp" 3
}
# 21 "/usr/include/boost-1_42/boost/integer.hpp" 2

# 1 "/usr/include/boost-1_42/boost/cstdint.hpp" 1
# 23 "/usr/include/boost-1_42/boost/integer.hpp" 2
# 33 "/usr/include/boost-1_42/boost/integer.hpp"
       
# 34 "/usr/include/boost-1_42/boost/integer.hpp" 3


namespace boost
{





  template< typename LeastInt >
  struct int_fast_t
  {
     typedef LeastInt fast;
     typedef fast type;
  };

  namespace detail{


  template< int Category > struct int_least_helper {};





  template<> struct int_least_helper<1> { typedef boost::long_long_type least; };

  template<> struct int_least_helper<2> { typedef long least; };
  template<> struct int_least_helper<3> { typedef int least; };
  template<> struct int_least_helper<4> { typedef short least; };
  template<> struct int_least_helper<5> { typedef signed char least; };

  template<> struct int_least_helper<6> { typedef boost::ulong_long_type least; };

  template<> struct int_least_helper<7> { typedef unsigned long least; };
  template<> struct int_least_helper<8> { typedef unsigned int least; };
  template<> struct int_least_helper<9> { typedef unsigned short least; };
  template<> struct int_least_helper<10> { typedef unsigned char least; };

  template <int Bits>
  struct exact_signed_base_helper{};
  template <int Bits>
  struct exact_unsigned_base_helper{};

  template <> struct exact_signed_base_helper<sizeof(signed char)* 8> { typedef signed char exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned char)* 8> { typedef unsigned char exact; };

  template <> struct exact_signed_base_helper<sizeof(short)* 8> { typedef short exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned short)* 8> { typedef unsigned short exact; };


  template <> struct exact_signed_base_helper<sizeof(int)* 8> { typedef int exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* 8> { typedef unsigned int exact; };


  template <> struct exact_signed_base_helper<sizeof(long)* 8> { typedef long exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* 8> { typedef unsigned long exact; };
# 102 "/usr/include/boost-1_42/boost/integer.hpp" 3
  }




  template< int Bits >
  struct int_t : public detail::exact_signed_base_helper<Bits>
  {
      typedef typename detail::int_least_helper
        <

          (Bits-1 <= (int)(sizeof(boost::long_long_type) * 8)) +



          (Bits-1 <= ::std::numeric_limits<long>::digits) +
          (Bits-1 <= ::std::numeric_limits<int>::digits) +
          (Bits-1 <= ::std::numeric_limits<short>::digits) +
          (Bits-1 <= ::std::numeric_limits<signed char>::digits)
        >::least least;
      typedef typename int_fast_t<least>::type fast;
  };


  template< int Bits >
  struct uint_t : public detail::exact_unsigned_base_helper<Bits>
  {
# 139 "/usr/include/boost-1_42/boost/integer.hpp" 3
      typedef typename detail::int_least_helper
        <
          5 +

          (Bits-1 <= (int)(sizeof(boost::long_long_type) * 8)) +



          (Bits <= ::std::numeric_limits<unsigned long>::digits) +
          (Bits <= ::std::numeric_limits<unsigned int>::digits) +
          (Bits <= ::std::numeric_limits<unsigned short>::digits) +
          (Bits <= ::std::numeric_limits<unsigned char>::digits)
        >::least least;

      typedef typename int_fast_t<least>::type fast;

  };





  template< boost::long_long_type MaxValue >



  struct int_max_value_t
  {
      typedef typename detail::int_least_helper
        <

          (MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +



          (MaxValue <= ::boost::integer_traits<long>::const_max) +
          (MaxValue <= ::boost::integer_traits<int>::const_max) +
          (MaxValue <= ::boost::integer_traits<short>::const_max) +
          (MaxValue <= ::boost::integer_traits<signed char>::const_max)
        >::least least;
      typedef typename int_fast_t<least>::type fast;
  };


  template< boost::long_long_type MinValue >



  struct int_min_value_t
  {
      typedef typename detail::int_least_helper
        <

          (MinValue >= ::boost::integer_traits<boost::long_long_type>::const_min) +



          (MinValue >= ::boost::integer_traits<long>::const_min) +
          (MinValue >= ::boost::integer_traits<int>::const_min) +
          (MinValue >= ::boost::integer_traits<short>::const_min) +
          (MinValue >= ::boost::integer_traits<signed char>::const_min)
        >::least least;
      typedef typename int_fast_t<least>::type fast;
  };



  template< boost::ulong_long_type MaxValue >



  struct uint_value_t
  {
# 233 "/usr/include/boost-1_42/boost/integer.hpp" 3
      typedef typename detail::int_least_helper
        <
          5 +

          (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +



          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max)
        >::least least;

      typedef typename int_fast_t<least>::type fast;
  };


}
# 22 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/intrinsics.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp" 2

# 1 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_void.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/is_void.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/is_void.hpp" 2

namespace boost {





template< typename T > struct is_void : ::boost::integral_constant<bool,false> { };
template<> struct is_void< void > : ::boost::integral_constant<bool,true> { };


template<> struct is_void< void const > : ::boost::integral_constant<bool,true> { };
template<> struct is_void< void volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_void< void const volatile > : ::boost::integral_constant<bool,true> { };




}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 37 "/usr/include/boost-1_42/boost/type_traits/is_void.hpp" 2
# 14 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 1
# 12 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_integral.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/is_integral.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/is_integral.hpp" 2

namespace boost {







template< typename T > struct is_integral : ::boost::integral_constant<bool,false> { };

template<> struct is_integral< unsigned char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< unsigned short > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< unsigned int > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< unsigned long > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long const volatile > : ::boost::integral_constant<bool,true> { };

template<> struct is_integral< signed char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< signed short > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< signed int > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< signed long > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long const volatile > : ::boost::integral_constant<bool,true> { };

template<> struct is_integral< bool > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char const volatile > : ::boost::integral_constant<bool,true> { };





template<> struct is_integral< wchar_t > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t const volatile > : ::boost::integral_constant<bool,true> { };
# 65 "/usr/include/boost-1_42/boost/type_traits/is_integral.hpp"
template<> struct is_integral< ::boost::ulong_long_type > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< ::boost::long_long_type > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type const volatile > : ::boost::integral_constant<bool,true> { };







}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 77 "/usr/include/boost-1_42/boost/type_traits/is_integral.hpp" 2
# 14 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_float.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/is_float.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 14 "/usr/include/boost-1_42/boost/type_traits/is_float.hpp" 2

namespace boost {


template< typename T > struct is_float : ::boost::integral_constant<bool,false> { };
template<> struct is_float< float > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_float< double > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_float< long double > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double const volatile > : ::boost::integral_constant<bool,true> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 26 "/usr/include/boost-1_42/boost/type_traits/is_float.hpp" 2
# 15 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/ice_or.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/detail/ice_or.hpp"
namespace boost {
namespace type_traits {

template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
struct ice_or;

template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_or
{
    static const bool value = true;
};

template <>
struct ice_or<false, false, false, false, false, false, false>
{
    static const bool value = false;
};

}
}
# 16 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 2




# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 21 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 2

namespace boost {


namespace detail {

template< typename T >
struct is_arithmetic_impl
{
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value)



                  ;
};

}






template< typename T > struct is_arithmetic : ::boost::integral_constant<bool,::boost::detail::is_arithmetic_impl<T>::value> { };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 50 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 2
# 13 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_enum.hpp" 1
# 32 "/usr/include/boost-1_42/boost/type_traits/is_enum.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 33 "/usr/include/boost-1_42/boost/type_traits/is_enum.hpp" 2

namespace boost {
# 181 "/usr/include/boost-1_42/boost/type_traits/is_enum.hpp"
template< typename T > struct is_enum : ::boost::integral_constant<bool,__is_enum(T)> { };



}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 188 "/usr/include/boost-1_42/boost/type_traits/is_enum.hpp" 2
# 14 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 1
# 24 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp" 1
# 28 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp" 1
# 24 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 1
# 25 "/usr/include/boost-1_42/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"
namespace boost {
namespace type_traits {

template <typename T>
struct is_mem_fun_pointer_impl
{
    static const bool value = false;
};





template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) > { static const bool value = true; };



template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() const > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() volatile > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { static const bool value = true; };


template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) const > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) volatile > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) > { static const bool value = true; };



template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { static const bool value = true; };


template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile > { static const bool value = true; };
# 776 "/usr/include/boost-1_42/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"
}
}
# 25 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp" 2
# 36 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 37 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp" 2

namespace boost {





template< typename T > struct is_member_function_pointer : ::boost::integral_constant<bool,::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value> { };
# 132 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 135 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp" 2
# 29 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp" 2
# 39 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 40 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp" 2

namespace boost {
# 50 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp"
template< typename T > struct is_member_pointer : ::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value> { };
template< typename T, typename U > struct is_member_pointer< U T::* > : ::boost::integral_constant<bool,true> { };


template< typename T, typename U > struct is_member_pointer< U T::*const > : ::boost::integral_constant<bool,true> { };
template< typename T, typename U > struct is_member_pointer< U T::*volatile > : ::boost::integral_constant<bool,true> { };
template< typename T, typename U > struct is_member_pointer< U T::*const volatile > : ::boost::integral_constant<bool,true> { };
# 112 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 115 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp" 2
# 25 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/ice_and.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/ice_and.hpp"
namespace boost {
namespace type_traits {

template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
struct ice_and;

template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_and
{
    static const bool value = false;
};

template <>
struct ice_and<true, true, true, true, true, true, true>
{
    static const bool value = true;
};

}
}
# 26 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/ice_not.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/detail/ice_not.hpp"
namespace boost {
namespace type_traits {

template <bool b>
struct ice_not
{
    static const bool value = true;
};

template <>
struct ice_not<true>
{
    static const bool value = false;
};

}
}
# 27 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 2
# 41 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 42 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 2

namespace boost {





namespace detail {

template< typename T > struct is_pointer_helper
{
    static const bool value = false;
};
# 63 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp"
template< typename T > struct is_pointer_helper<T*> { static const bool value = true; };



template< typename T >
struct is_pointer_impl
{
# 80 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp"
    static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value)






         ;

};

}

template< typename T > struct is_pointer : ::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> { };
# 158 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 161 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 2
# 15 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 2





# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 21 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct is_scalar_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T>::value, ::boost::is_enum<T>::value, ::boost::is_pointer<T>::value, ::boost::is_member_pointer<T>::value >::value)





                ;
};



template <> struct is_scalar_impl<void>{ static const bool value = false; };

template <> struct is_scalar_impl<void const>{ static const bool value = false; };
template <> struct is_scalar_impl<void volatile>{ static const bool value = false; };
template <> struct is_scalar_impl<void const volatile>{ static const bool value = false; };


}

template< typename T > struct is_scalar : ::boost::integral_constant<bool,::boost::detail::is_scalar_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 54 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 2
# 15 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 2



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 19 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 2


# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 2

namespace boost {


template< typename T > struct is_POD;

namespace detail {



template <typename T> struct is_pod_impl
{
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_scalar<T>::value, ::boost::is_void<T>::value, __is_pod(T) >::value)





                   ;
};


template <typename T, std::size_t sz>
struct is_pod_impl<T[sz]>
    : is_pod_impl<T>
{
};
# 118 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp"
template<> struct is_pod_impl< void > { static const bool value = (true); };


template<> struct is_pod_impl< void const > { static const bool value = (true); };
template<> struct is_pod_impl< void volatile > { static const bool value = (true); };
template<> struct is_pod_impl< void const volatile > { static const bool value = (true); };


}

template< typename T > struct is_POD : ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { };
template< typename T > struct is_pod : ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 134 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp" 2





# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_copy_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod<T>::value, (__has_trivial_copy(T) && !is_reference<T>::value) >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value)






                ;
};

}

template< typename T > struct has_trivial_copy : ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { };
template< typename T > struct has_trivial_copy_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 48 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp" 2
# 23 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/has_trivial_destructor.hpp" 1
# 18 "/usr/include/boost-1_42/boost/type_traits/has_trivial_destructor.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 19 "/usr/include/boost-1_42/boost/type_traits/has_trivial_destructor.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_dtor_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_destructor(T) >::value)



                ;
};

}

template< typename T > struct has_trivial_destructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_dtor_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 41 "/usr/include/boost-1_42/boost/type_traits/has_trivial_destructor.hpp" 2
# 24 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2



# 1 "/usr/include/boost-1_42/boost/type_traits/composite_traits.hpp" 1
# 16 "/usr/include/boost-1_42/boost/type_traits/composite_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp" 1
# 24 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 25 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp" 2


# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 28 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp" 2

namespace boost {




template< typename T > struct is_array : ::boost::integral_constant<bool,false> { };

template< typename T, std::size_t N > struct is_array< T[N] > : ::boost::integral_constant<bool,true> { };
template< typename T, std::size_t N > struct is_array< T const[N] > : ::boost::integral_constant<bool,true> { };
template< typename T, std::size_t N > struct is_array< T volatile[N] > : ::boost::integral_constant<bool,true> { };
template< typename T, std::size_t N > struct is_array< T const volatile[N] > : ::boost::integral_constant<bool,true> { };

template< typename T > struct is_array< T[] > : ::boost::integral_constant<bool,true> { };
template< typename T > struct is_array< T const[] > : ::boost::integral_constant<bool,true> { };
template< typename T > struct is_array< T volatile[] > : ::boost::integral_constant<bool,true> { };
template< typename T > struct is_array< T const volatile[] > : ::boost::integral_constant<bool,true> { };
# 87 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 90 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp" 2
# 17 "/usr/include/boost-1_42/boost/type_traits/composite_traits.hpp" 2





# 1 "/usr/include/boost-1_42/boost/type_traits/is_union.hpp" 1
# 19 "/usr/include/boost-1_42/boost/type_traits/is_union.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 20 "/usr/include/boost-1_42/boost/type_traits/is_union.hpp" 2

namespace boost {

namespace detail {
# 36 "/usr/include/boost-1_42/boost/type_traits/is_union.hpp"
template <typename T> struct is_union_impl
{
   static const bool value = __is_union(T);
};

}

template< typename T > struct is_union : ::boost::integral_constant<bool,::boost::detail::is_union_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 48 "/usr/include/boost-1_42/boost/type_traits/is_union.hpp" 2
# 23 "/usr/include/boost-1_42/boost/type_traits/composite_traits.hpp" 2
# 28 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/ice.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/ice.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/yes_no_type.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/yes_no_type.hpp"
namespace boost {
namespace type_traits {

typedef char yes_type;
struct no_type
{
   char padding[8];
};

}
}
# 15 "/usr/include/boost-1_42/boost/type_traits/ice.hpp" 2



# 1 "/usr/include/boost-1_42/boost/type_traits/detail/ice_eq.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/detail/ice_eq.hpp"
namespace boost {
namespace type_traits {

template <int b1, int b2>
struct ice_eq
{
    static const bool value = (b1 == b2);
};

template <int b1, int b2>
struct ice_ne
{
    static const bool value = (b1 != b2);
};


template <int b1, int b2> bool const ice_eq<b1,b2>::value;
template <int b1, int b2> bool const ice_ne<b1,b2>::value;


}
}
# 19 "/usr/include/boost-1_42/boost/type_traits/ice.hpp" 2
# 29 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
# 1 "/usr/include/boost-1_42/boost/ref.hpp" 1
# 11 "/usr/include/boost-1_42/boost/ref.hpp"
# 1 "/usr/include/boost-1_42/boost/utility/addressof.hpp" 1
# 18 "/usr/include/boost-1_42/boost/utility/addressof.hpp"
namespace boost
{

namespace detail
{

template<class T> struct addr_impl_ref
{
    T & v_;

    inline addr_impl_ref( T & v ): v_( v ) {}
    inline operator T& () const { return v_; }

private:
    addr_impl_ref & operator=(const addr_impl_ref &);
};

template<class T> struct addressof_impl
{
    static inline T * f( T & v, long )
    {
        return reinterpret_cast<T*>(
            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
    }

    static inline T * f( T * v, int )
    {
        return v;
    }
};

}

template<class T> T * addressof( T & v )
{






    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );


}
# 100 "/usr/include/boost-1_42/boost/utility/addressof.hpp"
}
# 12 "/usr/include/boost-1_42/boost/ref.hpp" 2
# 29 "/usr/include/boost-1_42/boost/ref.hpp"
namespace boost
{

template<class T> class reference_wrapper
{
public:
    typedef T type;







    explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}



    operator T& () const { return *t_; }

    T& get() const { return *t_; }

    T* get_pointer() const { return t_; }

private:

    T* t_;
};







template<class T> inline reference_wrapper<T> const ref(T & t)
{
    return reference_wrapper<T>(t);
}

template<class T> inline reference_wrapper<T const> const cref(T const & t)
{
    return reference_wrapper<T const>(t);
}





template<typename T>
class is_reference_wrapper
    : public mpl::false_
{
};

template<typename T>
class unwrap_reference
{
 public:
    typedef T type;
};
# 106 "/usr/include/boost-1_42/boost/ref.hpp"
template<typename T> class is_reference_wrapper< reference_wrapper<T> > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> > { public: typedef T type; };

template<typename T> class is_reference_wrapper< reference_wrapper<T> const > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const > { public: typedef T type; };
template<typename T> class is_reference_wrapper< reference_wrapper<T> volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> volatile > { public: typedef T type; };
template<typename T> class is_reference_wrapper< reference_wrapper<T> const volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const volatile > { public: typedef T type; };
# 176 "/usr/include/boost-1_42/boost/ref.hpp"
template <class T> inline typename unwrap_reference<T>::type&
unwrap_ref(T& t)
{
    return t;
}

template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
{
    return r.get_pointer();
}

}
# 30 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/if.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/if.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/integral.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/eti.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp" 2
# 73 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename T > struct value_type_wknd
{
    typedef typename T::value_type type;
};
# 87 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp"
}}}
# 18 "/usr/include/boost-1_42/boost/mpl/if.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/lambda_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/lambda_fwd.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/void_fwd.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/void_fwd.hpp"
namespace mpl_ {

struct void_;

}
namespace boost { namespace mpl { using ::mpl_::void_; } }
# 18 "/usr/include/boost-1_42/boost/mpl/lambda_fwd.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/na.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/na.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/na_fwd.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/na_fwd.hpp"
namespace mpl_ {


struct na
{
    typedef na type;
    enum { value = 0 };
};

}
namespace boost { namespace mpl { using ::mpl_::na; } }
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/na.hpp" 2



namespace boost { namespace mpl {

template< typename T >
struct is_na
    : false_
{



};

template<>
struct is_na<na>
    : true_
{



};

template< typename T >
struct is_not_na
    : true_
{



};

template<>
struct is_not_na<na>
    : false_
{



};


template< typename T, typename U > struct if_na
{
    typedef T type;
};

template< typename U > struct if_na<na,U>
{
    typedef U type;
};
# 93 "/usr/include/boost-1_42/boost/mpl/aux_/na.hpp"
}}
# 19 "/usr/include/boost-1_42/boost/mpl/lambda_fwd.hpp" 2





# 1 "/usr/include/boost-1_42/boost/mpl/aux_/lambda_arity_param.hpp" 1
# 25 "/usr/include/boost-1_42/boost/mpl/lambda_fwd.hpp" 2


namespace boost { namespace mpl {

template<
      typename T = na
    , typename Tag = void_
    , typename Arity = int_< aux::template_arity<T>::value >


    >
struct lambda;

}}
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp" 2



# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arity.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/arity.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/dtp.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/arity.hpp" 2
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp" 2




# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/enum.hpp" 1
# 28 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/limits/arity.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2




# 1 "/usr/include/boost-1_42/boost/preprocessor/logical/and.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/logical/and.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/logical/bitand.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/logical/and.hpp" 2
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/identity.hpp" 1
# 15 "/usr/include/boost-1_42/boost/preprocessor/identity.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/facilities/identity.hpp" 1
# 16 "/usr/include/boost-1_42/boost/preprocessor/identity.hpp" 2
# 24 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/empty.hpp" 1
# 25 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 66 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/add.hpp" 1
# 17 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/add.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/dec.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/add.hpp" 2


# 1 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp" 2
# 41 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_left.hpp" 1
# 17 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_left.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/control/expr_iif.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_left.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/list/adt.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/list/adt.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/is_binary.hpp" 1
# 16 "/usr/include/boost-1_42/boost/preprocessor/detail/is_binary.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/check.hpp" 1
# 17 "/usr/include/boost-1_42/boost/preprocessor/detail/is_binary.hpp" 2
# 19 "/usr/include/boost-1_42/boost/preprocessor/list/adt.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/logical/compl.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/list/adt.hpp" 2
# 20 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_left.hpp" 2
# 42 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp" 2
# 22 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/list/fold_right.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/list/fold_right.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/usr/include/boost-1_42/boost/preprocessor/list/fold_right.hpp" 2
# 37 "/usr/include/boost-1_42/boost/preprocessor/list/fold_right.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_right.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_right.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/list/reverse.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_right.hpp" 2
# 38 "/usr/include/boost-1_42/boost/preprocessor/list/fold_right.hpp" 2
# 23 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 2
# 48 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/control/detail/while.hpp" 1
# 49 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 2
# 21 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/add.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/elem.hpp" 1
# 22 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/add.hpp" 2
# 67 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/sub.hpp" 1
# 68 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 29 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp" 2
# 20 "/usr/include/boost-1_42/boost/mpl/if.hpp" 2





namespace boost { namespace mpl {



template<
      bool C
    , typename T1
    , typename T2
    >
struct if_c
{
    typedef T1 type;
};

template<
      typename T1
    , typename T2
    >
struct if_c<false,T1,T2>
{
    typedef T2 type;
};



template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = na
    >
struct if_
{
 private:

    typedef if_c<



          static_cast<bool>(T1::value)

        , T2
        , T3
        > almost_type_;

 public:
    typedef typename almost_type_::type type;

   
};
# 131 "/usr/include/boost-1_42/boost/mpl/if.hpp"
template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }

}}
# 31 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2

# 1 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 14 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp" 2



# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2


# 1 "/usr/include/boost-1_42/boost/mpl/size_t.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/size_t.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/size_t_fwd.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/size_t_fwd.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_42/boost/mpl/size_t_fwd.hpp" 2

namespace mpl_ {

template< std::size_t N > struct size_t;

}
namespace boost { namespace mpl { using ::mpl_::size_t; } }
# 18 "/usr/include/boost-1_42/boost/mpl/size_t.hpp" 2





# 1 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 1
# 40 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
namespace mpl_ {

template< std::size_t N >
struct size_t
{
    static const std::size_t value = N;





    typedef size_t type;

    typedef std::size_t value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
    typedef mpl_::size_t< static_cast<std::size_t>((value + 1)) > next;
    typedef mpl_::size_t< static_cast<std::size_t>((value - 1)) > prior;






    operator std::size_t() const { return static_cast<std::size_t>(this->value); }
};


template< std::size_t N >
std::size_t const mpl_::size_t< N >::value;


}
# 24 "/usr/include/boost-1_42/boost/mpl/size_t.hpp" 2
# 18 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2
# 18 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp" 2
# 27 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp"
namespace boost {

template <typename T> struct alignment_of;


namespace detail {





template <typename T>
struct alignment_of_hack
{
    char c;
    T t;
    alignment_of_hack();
};




template <unsigned A, unsigned S>
struct alignment_logic
{
    static const std::size_t value = A < S ? A : S;
};


template< typename T >
struct alignment_of_impl
{
# 83 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp"
   static const std::size_t value = __alignof__(T);

};

}

template< typename T > struct alignment_of : ::boost::integral_constant<std::size_t,::boost::detail::alignment_of_impl<T>::value> { };




template <typename T>
struct alignment_of<T&>
    : alignment_of<T*>
{
};
# 109 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp"
template<> struct alignment_of<void> : ::boost::integral_constant<std::size_t,0> { };

template<> struct alignment_of<void const> : ::boost::integral_constant<std::size_t,0> { };
template<> struct alignment_of<void volatile> : ::boost::integral_constant<std::size_t,0> { };
template<> struct alignment_of<void const volatile> : ::boost::integral_constant<std::size_t,0> { };


}
# 125 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_undef.hpp" 1
# 126 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp" 2
# 33 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2

# 1 "/usr/include/boost-1_42/boost/utility/enable_if.hpp" 1
# 24 "/usr/include/boost-1_42/boost/utility/enable_if.hpp"
namespace boost
{

  template <bool B, class T = void>
  struct enable_if_c {
    typedef T type;
  };

  template <class T>
  struct enable_if_c<false, T> {};

  template <class Cond, class T = void>
  struct enable_if : public enable_if_c<Cond::value, T> {};

  template <bool B, class T>
  struct lazy_enable_if_c {
    typedef typename T::type type;
  };

  template <class T>
  struct lazy_enable_if_c<false, T> {};

  template <class Cond, class T>
  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};


  template <bool B, class T = void>
  struct disable_if_c {
    typedef T type;
  };

  template <class T>
  struct disable_if_c<true, T> {};

  template <class Cond, class T = void>
  struct disable_if : public disable_if_c<Cond::value, T> {};

  template <bool B, class T>
  struct lazy_disable_if_c {
    typedef typename T::type type;
  };

  template <class T>
  struct lazy_disable_if_c<true, T> {};

  template <class Cond, class T>
  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};

}
# 35 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2



# 1 "/usr/include/boost-1_42/boost/function_equal.hpp" 1
# 13 "/usr/include/boost-1_42/boost/function_equal.hpp"
namespace boost {

template<typename F, typename G>
  bool function_equal_impl(const F& f, const G& g, long)
  { return f == g; }




template<typename F, typename G>
  bool function_equal(const F& f, const G& g)
  { return function_equal_impl(f, g, 0); }

}
# 39 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
# 1 "/usr/include/boost-1_42/boost/function/function_fwd.hpp" 1
# 28 "/usr/include/boost-1_42/boost/function/function_fwd.hpp"
namespace boost {
  class bad_function_call;



  template<typename Signature> class function;

  template<typename Signature>
  inline void swap(function<Signature>& f1, function<Signature>& f2)
  {
    f1.swap(f2);
  }



  template<typename R> class function0;
  template<typename R, typename T1> class function1;
  template<typename R, typename T1, typename T2> class function2;
  template<typename R, typename T1, typename T2, typename T3> class function3;
  template<typename R, typename T1, typename T2, typename T3, typename T4>
    class function4;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5>
    class function5;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6>
    class function6;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7>
    class function7;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7, typename T8>
    class function8;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7, typename T8, typename T9>
    class function9;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7, typename T8, typename T9,
           typename T10>
    class function10;
}
# 40 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
# 62 "/usr/include/boost-1_42/boost/function/function_base.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 2 3
# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  using ::memchr;
  using ::memcmp;
  using ::memcpy;
  using ::memmove;
  using ::memset;
  using ::strcat;
  using ::strcmp;
  using ::strcoll;
  using ::strcpy;
  using ::strcspn;
  using ::strerror;
  using ::strlen;
  using ::strncat;
  using ::strncmp;
  using ::strncpy;
  using ::strspn;
  using ::strtok;
  using ::strxfrm;
  using ::strchr;
  using ::strpbrk;
  using ::strrchr;
  using ::strstr;
# 121 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
}
# 63 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
# 89 "/usr/include/boost-1_42/boost/function/function_base.hpp"
namespace boost {
  namespace detail {
    namespace function {
      class X;







      union function_buffer
      {

        mutable void* obj_ptr;


        struct type_t {

          const detail::sp_typeinfo* type;


          bool const_qualified;

          bool volatile_qualified;
        } type;


        mutable void (*func_ptr)();


        struct bound_memfunc_ptr_t {
          void (X::*memfunc_ptr)(int);
          void* obj_ptr;
        } bound_memfunc_ptr;



        struct obj_ref_t {
          mutable void* obj_ptr;
          bool is_const_qualified;
          bool is_volatile_qualified;
        } obj_ref;


        mutable char data;
      };







      struct unusable
      {
        unusable() {}
        template<typename T> unusable(const T&) {}
      };





      template<typename T> struct function_return_type { typedef T type; };

      template<>
      struct function_return_type<void>
      {
        typedef unusable type;
      };


      enum functor_manager_operation_type {
        clone_functor_tag,
        move_functor_tag,
        destroy_functor_tag,
        check_functor_type_tag,
        get_functor_type_tag
      };


      struct function_ptr_tag {};
      struct function_obj_tag {};
      struct member_ptr_tag {};
      struct function_obj_ref_tag {};

      template<typename F>
      class get_function_tag
      {
        typedef typename mpl::if_c<(is_pointer<F>::value),
                                   function_ptr_tag,
                                   function_obj_tag>::type ptr_or_obj_tag;

        typedef typename mpl::if_c<(is_member_pointer<F>::value),
                                   member_ptr_tag,
                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;

        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
                                   function_obj_ref_tag,
                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;

      public:
        typedef or_ref_tag type;
      };



      template<typename F>
      struct reference_manager
      {
        static inline void
        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
               functor_manager_operation_type op)
        {
          switch (op) {
          case clone_functor_tag:
            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
            return;

          case move_functor_tag:
            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
            in_buffer.obj_ref.obj_ptr = 0;
            return;

          case destroy_functor_tag:
            out_buffer.obj_ref.obj_ptr = 0;
            return;

          case check_functor_type_tag:
            {
              const detail::sp_typeinfo& check_type
                = *out_buffer.type.type;



              if ((std::strcmp((check_type).name(),(typeid(F)).name()) == 0)
                  && (!in_buffer.obj_ref.is_const_qualified
                      || out_buffer.type.const_qualified)
                  && (!in_buffer.obj_ref.is_volatile_qualified
                      || out_buffer.type.volatile_qualified))
                out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
              else
                out_buffer.obj_ptr = 0;
            }
            return;

          case get_functor_type_tag:
            out_buffer.type.type = &typeid(F);
            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
            return;
          }
        }
      };





      template<typename F>
      struct function_allows_small_object_optimization
      {
        static const bool value = ((sizeof(F) <= sizeof(function_buffer) && (alignment_of<function_buffer>::value % alignment_of<F>::value == 0)))



                                                       ;
      };

      template <typename F,typename A>
      struct functor_wrapper: public F, public A
      {
        functor_wrapper( F f, A a ):
          F(f),
          A(a)
        {
        }

 functor_wrapper(const functor_wrapper& f) :
          F(static_cast<const F&>(f)),
          A(static_cast<const A&>(f))
 {
 }
      };





      template<typename Functor>
      struct functor_manager_common
      {
        typedef Functor functor_type;


        static inline void
        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag)
            out_buffer.func_ptr = in_buffer.func_ptr;
          else if (op == move_functor_tag) {
            out_buffer.func_ptr = in_buffer.func_ptr;
            in_buffer.func_ptr = 0;
          } else if (op == destroy_functor_tag)
            out_buffer.func_ptr = 0;
          else if (op == check_functor_type_tag) {
            const detail::sp_typeinfo& check_type
              = *out_buffer.type.type;
            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
              out_buffer.obj_ptr = &in_buffer.func_ptr;
            else
              out_buffer.obj_ptr = 0;
          } else {
            out_buffer.type.type = &typeid(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
        }


        static inline void
        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag || op == move_functor_tag) {
            const functor_type* in_functor =
              reinterpret_cast<const functor_type*>(&in_buffer.data);
            new ((void*)&out_buffer.data) functor_type(*in_functor);

            if (op == move_functor_tag) {
              reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
            }
          } else if (op == destroy_functor_tag) {

            reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
          } else if (op == check_functor_type_tag) {
            const detail::sp_typeinfo& check_type
              = *out_buffer.type.type;
            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
              out_buffer.obj_ptr = &in_buffer.data;
            else
              out_buffer.obj_ptr = 0;
          } else {
            out_buffer.type.type = &typeid(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
        }
      };

      template<typename Functor>
      struct functor_manager
      {
      private:
        typedef Functor functor_type;


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::false_)
        {
          if (op == clone_functor_tag) {



            const functor_type* f =
              (const functor_type*)(in_buffer.obj_ptr);
            functor_type* new_f = new functor_type(*f);
            out_buffer.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
            out_buffer.obj_ptr = in_buffer.obj_ptr;
            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {

            functor_type* f =
              static_cast<functor_type*>(out_buffer.obj_ptr);
            delete f;
            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
            const detail::sp_typeinfo& check_type
              = *out_buffer.type.type;
            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
              out_buffer.obj_ptr = 0;
          } else {
            out_buffer.type.type = &typeid(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
        }




        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, member_ptr_tag)
        {
          manager(in_buffer, out_buffer, op, mpl::true_());
        }

      public:


        static inline void
        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
            out_buffer.type.type = &typeid(functor_type);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
            return;

          default:
            manager(in_buffer, out_buffer, op, tag_type());
            return;
          }
        }
      };

      template<typename Functor, typename Allocator>
      struct functor_manager_a
      {
      private:
        typedef Functor functor_type;


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::false_)
        {
          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;

          if (op == clone_functor_tag) {



            const functor_wrapper_type* f =
              (const functor_wrapper_type*)(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
            wrapper_allocator.construct(copy, *f);


            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
            out_buffer.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
            out_buffer.obj_ptr = in_buffer.obj_ptr;
            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {

            functor_wrapper_type* victim =
              static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
            wrapper_allocator.destroy(victim);
            wrapper_allocator.deallocate(victim,1);
            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
            const detail::sp_typeinfo& check_type
              = *out_buffer.type.type;
            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
              out_buffer.obj_ptr = 0;
          } else {
            out_buffer.type.type = &typeid(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
        }




        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }

      public:


        static inline void
        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
            out_buffer.type.type = &typeid(functor_type);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
            return;

          default:
            manager(in_buffer, out_buffer, op, tag_type());
            return;
          }
        }
      };


      struct useless_clear_type {};
# 609 "/usr/include/boost-1_42/boost/function/function_base.hpp"
      struct vtable_base
      {
        void (*manager)(const function_buffer& in_buffer,
                        function_buffer& out_buffer,
                        functor_manager_operation_type op);
      };
    }
  }







class function_base
{
public:
  function_base() : vtable(0) { }


  bool empty() const { return !vtable; }



  const detail::sp_typeinfo& target_type() const
  {
    if (!vtable) return typeid(void);

    detail::function::function_buffer type;
    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
    return *type.type.type;
  }

  template<typename Functor>
    Functor* target()
    {
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
      type_result.type.type = &typeid(Functor);
      type_result.type.const_qualified = is_const<Functor>::value;
      type_result.type.volatile_qualified = is_volatile<Functor>::value;
      get_vtable()->manager(functor, type_result,
                      detail::function::check_functor_type_tag);
      return static_cast<Functor*>(type_result.obj_ptr);
    }

  template<typename Functor>



    const Functor* target() const

    {
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
      type_result.type.type = &typeid(Functor);
      type_result.type.const_qualified = true;
      type_result.type.volatile_qualified = is_volatile<Functor>::value;
      get_vtable()->manager(functor, type_result,
                      detail::function::check_functor_type_tag);


      return (const Functor*)(type_result.obj_ptr);
    }

  template<typename F>
    bool contains(const F& f) const
    {



      if (const F* fp = this->template target<F>())

      {
        return function_equal(*fp, f);
      } else {
        return false;
      }
    }
# 715 "/usr/include/boost-1_42/boost/function/function_base.hpp"
public:
  detail::function::vtable_base* get_vtable() const {
    return reinterpret_cast<detail::function::vtable_base*>(
             reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
  }

  bool has_trivial_copy_and_destroy() const {
    return reinterpret_cast<std::size_t>(vtable) & 0x01;
  }

  detail::function::vtable_base* vtable;
  mutable detail::function::function_buffer functor;
};





class bad_function_call : public std::runtime_error
{
public:
  bad_function_call() : std::runtime_error("call to empty boost::function") {}
};


inline bool operator==(const function_base& f,
                       detail::function::useless_clear_type*)
{
  return f.empty();
}

inline bool operator!=(const function_base& f,
                       detail::function::useless_clear_type*)
{
  return !f.empty();
}

inline bool operator==(detail::function::useless_clear_type*,
                       const function_base& f)
{
  return f.empty();
}

inline bool operator!=(detail::function::useless_clear_type*,
                       const function_base& f)
{
  return !f.empty();
}
# 800 "/usr/include/boost-1_42/boost/function/function_base.hpp"
template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator==(const function_base& f, Functor g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return function_equal(*fp, g);
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator==(Functor g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return function_equal(g, *fp);
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator!=(const function_base& f, Functor g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return !function_equal(*fp, g);
    else return true;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator!=(Functor g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return !function_equal(g, *fp);
    else return true;
  }


template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator==(const function_base& f, reference_wrapper<Functor> g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return fp == g.get_pointer();
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator==(reference_wrapper<Functor> g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return g.get_pointer() == fp;
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator!=(const function_base& f, reference_wrapper<Functor> g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return fp != g.get_pointer();
    else return true;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator!=(reference_wrapper<Functor> g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return g.get_pointer() != fp;
    else return true;
  }



namespace detail {
  namespace function {
    inline bool has_empty_target(const function_base* f)
    {
      return f->empty();
    }







    inline bool has_empty_target(...)
    {
      return false;
    }

  }
}
}
# 18 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mem_fn.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mem_fn.hpp"
# 1 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp" 1
# 25 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp"
# 1 "/usr/include/boost-1_42/boost/get_pointer.hpp" 1
# 12 "/usr/include/boost-1_42/boost/get_pointer.hpp"
# 1 "/usr/include/boost-1_42/boost/config/no_tr1/memory.hpp" 1
# 13 "/usr/include/boost-1_42/boost/get_pointer.hpp" 2

namespace boost {



template<class T> T * get_pointer(T * p)
{
    return p;
}



template<class T> T * get_pointer(std::auto_ptr<T> const& p)
{
    return p.get();
}


}
# 26 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp" 2


namespace boost
{
# 207 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp"
namespace _mfi
{






# 1 "/usr/include/boost-1_42/boost/bind/mem_fn_template.hpp" 1
# 21 "/usr/include/boost-1_42/boost/bind/mem_fn_template.hpp"
template<class R, class T > class mf0
{
public:

    typedef R result_type;
    typedef T * argument_type;

private:

    typedef R ( T::*F) ();
    F f_;

    template<class U> R call(U & u, T const *) const
    {
        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_)();
    }

public:

    explicit mf0(F f): f_(f) {}

    R operator()(T * p) const
    {
        return (p->*f_)();
    }

    template<class U> R operator()(U & u) const
    {
        U const * p = 0;
        return call(u, p);
    }



    template<class U> R operator()(U const & u) const
    {
        U const * p = 0;
        return call(u, p);
    }



    R operator()(T & t) const
    {
        return (t.*f_)();
    }

    bool operator==(mf0 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf0 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T > class cmf0
{
public:

    typedef R result_type;
    typedef T const * argument_type;

private:

    typedef R ( T::*F) () const;
    F f_;

    template<class U> R call(U & u, T const *) const
    {
        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_)();
    }

public:

    explicit cmf0(F f): f_(f) {}

    template<class U> R operator()(U const & u) const
    {
        U const * p = 0;
        return call(u, p);
    }

    R operator()(T const & t) const
    {
        return (t.*f_)();
    }

    bool operator==(cmf0 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf0 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1 > class mf1
{
public:

    typedef R result_type;
    typedef T * first_argument_type;
    typedef A1 second_argument_type;

private:

    typedef R ( T::*F) (A1);
    F f_;

    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
    {
        return (u.*f_)(b1);
    }

    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
    {
        return (get_pointer(u)->*f_)(b1);
    }

public:

    explicit mf1(F f): f_(f) {}

    R operator()(T * p, A1 a1) const
    {
        return (p->*f_)(a1);
    }

    template<class U> R operator()(U & u, A1 a1) const
    {
        U const * p = 0;
        return call(u, p, a1);
    }



    template<class U> R operator()(U const & u, A1 a1) const
    {
        U const * p = 0;
        return call(u, p, a1);
    }



    R operator()(T & t, A1 a1) const
    {
        return (t.*f_)(a1);
    }

    bool operator==(mf1 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf1 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1 > class cmf1
{
public:

    typedef R result_type;
    typedef T const * first_argument_type;
    typedef A1 second_argument_type;

private:

    typedef R ( T::*F) (A1) const;
    F f_;

    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
    {
        return (u.*f_)(b1);
    }

    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
    {
        return (get_pointer(u)->*f_)(b1);
    }

public:

    explicit cmf1(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1) const
    {
        U const * p = 0;
        return call(u, p, a1);
    }

    R operator()(T const & t, A1 a1) const
    {
        return (t.*f_)(a1);
    }

    bool operator==(cmf1 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf1 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2 > class mf2
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2);
    F f_;

    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
    {
        return (u.*f_)(b1, b2);
    }

    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
    {
        return (get_pointer(u)->*f_)(b1, b2);
    }

public:

    explicit mf2(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2) const
    {
        return (p->*f_)(a1, a2);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
        return call(u, p, a1, a2);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
        return call(u, p, a1, a2);
    }



    R operator()(T & t, A1 a1, A2 a2) const
    {
        return (t.*f_)(a1, a2);
    }

    bool operator==(mf2 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf2 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2 > class cmf2
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2) const;
    F f_;

    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
    {
        return (u.*f_)(b1, b2);
    }

    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
    {
        return (get_pointer(u)->*f_)(b1, b2);
    }

public:

    explicit cmf2(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
        return call(u, p, a1, a2);
    }

    R operator()(T const & t, A1 a1, A2 a2) const
    {
        return (t.*f_)(a1, a2);
    }

    bool operator==(cmf2 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf2 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3 > class mf3
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3);
    F f_;

    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (u.*f_)(b1, b2, b3);
    }

    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3);
    }

public:

    explicit mf3(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
    {
        return (p->*f_)(a1, a2, a3);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
    {
        return (t.*f_)(a1, a2, a3);
    }

    bool operator==(mf3 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf3 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3 > class cmf3
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3) const;
    F f_;

    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (u.*f_)(b1, b2, b3);
    }

    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3);
    }

public:

    explicit cmf3(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
    {
        return (t.*f_)(a1, a2, a3);
    }

    bool operator==(cmf3 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf3 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4 > class mf4
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4);
    F f_;

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (u.*f_)(b1, b2, b3, b4);
    }

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
    }

public:

    explicit mf4(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return (p->*f_)(a1, a2, a3, a4);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return (t.*f_)(a1, a2, a3, a4);
    }

    bool operator==(mf4 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf4 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4 > class cmf4
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (u.*f_)(b1, b2, b3, b4);
    }

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
    }

public:

    explicit cmf4(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return (t.*f_)(a1, a2, a3, a4);
    }

    bool operator==(cmf4 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf4 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class mf5
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
    }

public:

    explicit mf5(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5);
    }

    bool operator==(mf5 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf5 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class cmf5
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
    }

public:

    explicit cmf5(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5);
    }

    bool operator==(cmf5 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf5 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class mf6
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
    }

public:

    explicit mf6(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6);
    }

    bool operator==(mf6 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf6 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class cmf6
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
    }

public:

    explicit cmf6(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6);
    }

    bool operator==(cmf6 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf6 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class mf7
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

public:

    explicit mf7(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    bool operator==(mf7 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf7 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class cmf7
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

public:

    explicit cmf7(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    bool operator==(cmf7 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf7 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class mf8
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

public:

    explicit mf8(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    bool operator==(mf8 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf8 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class cmf8
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

public:

    explicit cmf8(F f): f_(f) {}

    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    bool operator==(cmf8 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf8 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};
# 216 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp" 2
# 258 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp"
}
# 268 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp"
# 1 "/usr/include/boost-1_42/boost/bind/mem_fn_cc.hpp" 1
# 15 "/usr/include/boost-1_42/boost/bind/mem_fn_cc.hpp"
template<class R, class T> _mfi::mf0<R, T> mem_fn(R ( T::*f) ())
{
    return _mfi::mf0<R, T>(f);
}

template<class R, class T> _mfi::cmf0<R, T> mem_fn(R ( T::*f) () const)
{
    return _mfi::cmf0<R, T>(f);
}

template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R ( T::*f) (A1))
{
    return _mfi::mf1<R, T, A1>(f);
}

template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R ( T::*f) (A1) const)
{
    return _mfi::cmf1<R, T, A1>(f);
}

template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2))
{
    return _mfi::mf2<R, T, A1, A2>(f);
}

template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2) const)
{
    return _mfi::cmf2<R, T, A1, A2>(f);
}

template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3))
{
    return _mfi::mf3<R, T, A1, A2, A3>(f);
}

template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3) const)
{
    return _mfi::cmf3<R, T, A1, A2, A3>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4))
{
    return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4) const)
{
    return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5))
{
    return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5) const)
{
    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6))
{
    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6) const)
{
    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7))
{
    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
{
    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
{
    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
{
    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}
# 269 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp" 2
# 311 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp"
namespace _mfi
{

template<class R, class T> class dm
{
public:

    typedef R const & result_type;
    typedef T const * argument_type;

private:

    typedef R (T::*F);
    F f_;

    template<class U> R const & call(U & u, T const *) const
    {
        return (u.*f_);
    }

    template<class U> R const & call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_);
    }

public:

    explicit dm(F f): f_(f) {}

    R & operator()(T * p) const
    {
        return (p->*f_);
    }

    R const & operator()(T const * p) const
    {
        return (p->*f_);
    }

    template<class U> R const & operator()(U const & u) const
    {
        return call(u, &u);
    }



    R & operator()(T & t) const
    {
        return (t.*f_);
    }

    R const & operator()(T const & t) const
    {
        return (t.*f_);
    }



    bool operator==(dm const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(dm const & rhs) const
    {
        return f_ != rhs.f_;
    }
};

}

template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
{
    return _mfi::dm<R, T>(f);
}

}
# 23 "/usr/include/boost-1_42/boost/mem_fn.hpp" 2
# 19 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/enum.hpp" 1
# 15 "/usr/include/boost-1_42/boost/preprocessor/enum.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum.hpp" 2



# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/rem.hpp" 1
# 25 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum.hpp" 2
# 16 "/usr/include/boost-1_42/boost/preprocessor/enum.hpp" 2
# 21 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/enum_params.hpp" 1
# 15 "/usr/include/boost-1_42/boost/preprocessor/enum_params.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_params.hpp" 1
# 16 "/usr/include/boost-1_42/boost/preprocessor/enum_params.hpp" 2
# 22 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
# 14 "/usr/include/boost-1_42/boost/function/function_template.hpp" 2
# 1 "/usr/include/boost-1_42/boost/detail/no_exceptions_support.hpp" 1
# 15 "/usr/include/boost-1_42/boost/function/function_template.hpp" 2
# 81 "/usr/include/boost-1_42/boost/function/function_template.hpp"
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R
       
        >
      struct function_invoker0
      {
        static R invoke(function_buffer& function_ptr
                        )
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f();
        }
      };

      template<
        typename FunctionPtr,
        typename R
       
        >
      struct void_function_invoker0
      {
        static void
        invoke(function_buffer& function_ptr
               )

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct function_obj_invoker0
      {
        static R invoke(function_buffer& function_obj_ptr
                        )

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct void_function_obj_invoker0
      {
        static void
        invoke(function_buffer& function_obj_ptr
               )

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct function_ref_invoker0
      {
        static R invoke(function_buffer& function_obj_ptr
                        )

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct void_function_ref_invoker0
      {
        static void
        invoke(function_buffer& function_obj_ptr
               )

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)();
        }
      };
# 230 "/usr/include/boost-1_42/boost/function/function_template.hpp"
      template<
        typename FunctionPtr,
        typename R
       
      >
      struct get_function_invoker0
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker0<
                            FunctionPtr,
                            R
                           
                          >,
                          function_invoker0<
                            FunctionPtr,
                            R
                           
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R
       
       >
      struct get_function_obj_invoker0
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker0<
                            FunctionObj,
                            R
                           
                          >,
                          function_obj_invoker0<
                            FunctionObj,
                            R
                           
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R
       
       >
      struct get_function_ref_invoker0
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker0<
                            FunctionObj,
                            R
                           
                          >,
                          function_ref_invoker0<
                            FunctionObj,
                            R
                           
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_42/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker0 { };


      template<>
      struct get_invoker0<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R >
        struct apply
        {
          typedef typename get_function_invoker0<
                             FunctionPtr,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R ,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker0<
                             FunctionPtr,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };
# 400 "/usr/include/boost-1_42/boost/function/function_template.hpp"
      template<>
      struct get_invoker0<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R >
        struct apply
        {
          typedef typename get_function_obj_invoker0<
                             FunctionObj,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R ,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker0<
                             FunctionObj,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker0<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R >
        struct apply
        {
          typedef typename get_function_ref_invoker0<
                             typename RefWrapper::type,
                             R
                            
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R ,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker0<
                             typename RefWrapper::type,
                             R
                            
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_42/boost/function/function_template.hpp"
      template<typename R >
      struct basic_vtable0
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                           
                                            );

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }
# 562 "/usr/include/boost-1_42/boost/function/function_template.hpp"
        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R
   
  >
  class function0 : public function_base
# 664 "/usr/include/boost-1_42/boost/function/function_template.hpp"
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable0<
              R >
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 0;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost-1_42/boost/function/function_template.hpp"
    static const int arity = 0;
   

    typedef function0 self_type;

    function0() : function_base() { }



    template<typename Functor>
    function0(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function0(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function0(clear_type*) : function_base() { }







    function0(const function0& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function0() { clear(); }
# 766 "/usr/include/boost-1_42/boost/function/function_template.hpp"
    result_type operator()() const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function0&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function0& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_42/boost/function/function_template.hpp"
    function0& operator=(const function0& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function0& other)
    {
      if (&other == this)
        return;

      function0 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function0& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker0<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R
                        >
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker0<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R
                         ,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function0& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R >
  inline void swap(function0<
                     R
                    
                   >& f1,
                   function0<
                     R
                    
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R >
  typename function0<
      R >::result_type
  inline
  function0<R >
  ::operator()() const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor );
  }



template<typename R >
  void operator==(const function0<
                          R
                          >&,
                  const function0<
                          R
                          >&);
template<typename R >
  void operator!=(const function0<
                          R
                          >&,
                  const function0<
                          R
                          >& );
# 1041 "/usr/include/boost-1_42/boost/function/function_template.hpp"
template<typename R
         >
class function<R (void)>
  : public function0<R >
{
  typedef function0<R > base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};




}
# 14 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 2
# 12 "/usr/include/boost-1_42/boost/function/function0.hpp" 2
# 14 "/usr/include/boost-1_42/boost/python/errors.hpp" 2

namespace boost { namespace python {

struct __attribute__ ((visibility("default"))) error_already_set
{
  virtual ~error_already_set();
};



 bool handle_exception_impl(function0<void>);

template <class T>
bool handle_exception(T f)
{
    return handle_exception_impl(function0<void>(boost::ref(f)));
}

namespace detail { inline void rethrow() { throw; } }

inline void handle_exception()
{
    handle_exception(detail::rethrow);
}

 void throw_error_already_set();

template <class T>
inline T* expect_non_null(T* x)
{
    if (x == 0)
        throw_error_already_set();
    return x;
}



 PyObject* pytype_check(PyTypeObject* pytype, PyObject* source);

}}
# 12 "/usr/include/boost-1_42/boost/python/handle.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/borrowed.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/borrowed.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/borrowed_ptr.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/detail/borrowed_ptr.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 1
# 17 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/has_trivial_assign.hpp" 1
# 22 "/usr/include/boost-1_42/boost/type_traits/has_trivial_assign.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 23 "/usr/include/boost-1_42/boost/type_traits/has_trivial_assign.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_assign_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_assign(T) >::value, ::boost::type_traits::ice_not< ::boost::is_const<T>::value >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value)







                ;
};

}

template< typename T > struct has_trivial_assign : ::boost::integral_constant<bool,::boost::detail::has_trivial_assign_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 49 "/usr/include/boost-1_42/boost/type_traits/has_trivial_assign.hpp" 2
# 18 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/has_trivial_constructor.hpp" 1
# 18 "/usr/include/boost-1_42/boost/type_traits/has_trivial_constructor.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 19 "/usr/include/boost-1_42/boost/type_traits/has_trivial_constructor.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_ctor_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_constructor(T) >::value)



                ;
};

}

template< typename T > struct has_trivial_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { };
template< typename T > struct has_trivial_default_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 42 "/usr/include/boost-1_42/boost/type_traits/has_trivial_constructor.hpp" 2
# 19 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2


# 1 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_constructor.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_constructor.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_constructor.hpp" 2

namespace boost {

namespace detail{

template <class T>
struct has_nothrow_constructor_imp{
   static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_constructor<T>::value, __has_nothrow_constructor(T) >::value)



                ;
};

}

template< typename T > struct has_nothrow_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { };
template< typename T > struct has_nothrow_default_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 38 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_constructor.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_copy.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_copy.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_copy.hpp" 2

namespace boost {

namespace detail{

template <class T>
struct has_nothrow_copy_imp{
   static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_copy<T>::value, (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value) >::value)



                ;
};

}

template< typename T > struct has_nothrow_copy : ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { };
template< typename T > struct has_nothrow_copy_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 38 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_copy.hpp" 2
# 23 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_assign.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_assign.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_assign.hpp" 2

namespace boost {

namespace detail{

template <class T>
struct has_nothrow_assign_imp{
   static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_assign<T>::value, (__has_nothrow_assign(T) && !is_volatile<T>::value) >::value)



                ;
};

}

template< typename T > struct has_nothrow_assign : ::boost::integral_constant<bool,::boost::detail::has_nothrow_assign_imp<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 37 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_assign.hpp" 2
# 24 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_base_and_derived.hpp" 1
# 24 "/usr/include/boost-1_42/boost/type_traits/is_base_and_derived.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 25 "/usr/include/boost-1_42/boost/type_traits/is_base_and_derived.hpp" 2

namespace boost {

namespace detail {
# 222 "/usr/include/boost-1_42/boost/type_traits/is_base_and_derived.hpp"
template <typename B, typename D>
struct is_base_and_derived_impl
{
    typedef typename remove_cv<B>::type ncvB;
    typedef typename remove_cv<D>::type ncvD;

    static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
};

}

template< typename Base, typename Derived > struct is_base_and_derived : ::boost::integral_constant<bool,(::boost::detail::is_base_and_derived_impl<Base,Derived>::value)> { };







template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : ::boost::integral_constant<bool,false> { };
template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : ::boost::integral_constant<bool,false> { };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : ::boost::integral_constant<bool,false> { };






}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 253 "/usr/include/boost-1_42/boost/type_traits/is_base_and_derived.hpp" 2
# 25 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_class.hpp" 1
# 37 "/usr/include/boost-1_42/boost/type_traits/is_class.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 38 "/usr/include/boost-1_42/boost/type_traits/is_class.hpp" 2

namespace boost {

namespace detail {
# 120 "/usr/include/boost-1_42/boost/type_traits/is_class.hpp"
template <typename T>
struct is_class_impl
{
    static const bool value = __is_class(T);
};


}





template< typename T > struct is_class : ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 139 "/usr/include/boost-1_42/boost/type_traits/is_class.hpp" 2
# 26 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_compound.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/is_compound.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_fundamental.hpp" 1
# 17 "/usr/include/boost-1_42/boost/type_traits/is_fundamental.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 18 "/usr/include/boost-1_42/boost/type_traits/is_fundamental.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct is_fundamental_impl
    : ::boost::type_traits::ice_or<
          ::boost::is_arithmetic<T>::value
        , ::boost::is_void<T>::value
        >
{
};

}





template< typename T > struct is_fundamental : ::boost::integral_constant<bool,::boost::detail::is_fundamental_impl<T>::value> { };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 44 "/usr/include/boost-1_42/boost/type_traits/is_fundamental.hpp" 2
# 14 "/usr/include/boost-1_42/boost/type_traits/is_compound.hpp" 2



# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 18 "/usr/include/boost-1_42/boost/type_traits/is_compound.hpp" 2

namespace boost {


namespace detail {

template <typename T>
struct is_compound_impl
{
   static const bool value = (::boost::type_traits::ice_not< ::boost::is_fundamental<T>::value >::value)


                 ;
};

}





template< typename T > struct is_compound : ::boost::integral_constant<bool,::boost::detail::is_compound_impl<T>::value> { };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 45 "/usr/include/boost-1_42/boost/type_traits/is_compound.hpp" 2
# 27 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp" 1
# 12 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp" 1
# 20 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/add_reference.hpp" 1
# 17 "/usr/include/boost-1_42/boost/type_traits/add_reference.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 18 "/usr/include/boost-1_42/boost/type_traits/add_reference.hpp" 2

namespace boost {

namespace detail {
# 55 "/usr/include/boost-1_42/boost/type_traits/add_reference.hpp"
template <typename T>
struct add_reference_impl
{
    typedef T& type;
};


template< typename T > struct add_reference_impl<T&> { typedef T& type; };





template<> struct add_reference_impl<void> { typedef void type; };

template<> struct add_reference_impl<void const> { typedef void const type; };
template<> struct add_reference_impl<void volatile> { typedef void volatile type; };
template<> struct add_reference_impl<void const volatile> { typedef void const volatile type; };


}

template< typename T > struct add_reference { typedef typename boost::detail::add_reference_impl<T>::type type; };







}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 88 "/usr/include/boost-1_42/boost/type_traits/add_reference.hpp" 2
# 21 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp" 2




# 1 "/usr/include/boost-1_42/boost/type_traits/is_abstract.hpp" 1
# 62 "/usr/include/boost-1_42/boost/type_traits/is_abstract.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 63 "/usr/include/boost-1_42/boost/type_traits/is_abstract.hpp" 2


namespace boost {
namespace detail{


template <class T>
struct is_abstract_imp
{
   static const bool value = __is_abstract(T);
};
# 141 "/usr/include/boost-1_42/boost/type_traits/is_abstract.hpp"
}


template< typename T > struct is_abstract : ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { };




}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 152 "/usr/include/boost-1_42/boost/type_traits/is_abstract.hpp" 2
# 26 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp" 2
# 36 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 37 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp" 2

namespace boost {
# 52 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
namespace detail {
# 119 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
struct any_conversion
{
    template <typename T> any_conversion(const volatile T&);
    template <typename T> any_conversion(T&);
};

template <typename T> struct checker
{
    static boost::type_traits::no_type _m_check(any_conversion ...);
    static boost::type_traits::yes_type _m_check(T, int);
};

template <typename From, typename To>
struct is_convertible_basic_impl
{
    static From _m_from;
    static bool const value = sizeof( detail::checker<To>::_m_check(_m_from, 0) )
        == sizeof(::boost::type_traits::yes_type);
};
# 291 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
template <typename From, typename To>
struct is_convertible_impl
{
    typedef typename add_reference<From>::type ref_type;
    static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::detail::is_convertible_basic_impl<ref_type,To>::value, ::boost::is_void<To>::value >::value, ::boost::type_traits::ice_not< ::boost::is_array<To>::value >::value >::value)
# 305 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
         ;
};


template <bool trivial1, bool trivial2, bool abstract_target>
struct is_convertible_impl_select
{
   template <class From, class To>
   struct rebind
   {
      typedef is_convertible_impl<From, To> type;
   };
};

template <>
struct is_convertible_impl_select<true, true, false>
{
   template <class From, class To>
   struct rebind
   {
      typedef true_type type;
   };
};

template <>
struct is_convertible_impl_select<false, false, true>
{
   template <class From, class To>
   struct rebind
   {
      typedef false_type type;
   };
};

template <>
struct is_convertible_impl_select<true, false, true>
{
   template <class From, class To>
   struct rebind
   {
      typedef false_type type;
   };
};

template <typename From, typename To>
struct is_convertible_impl_dispatch_base
{

   typedef is_convertible_impl_select<
      ::boost::is_arithmetic<From>::value,
      ::boost::is_arithmetic<To>::value,

      ::boost::is_abstract<To>::value



   > selector;



   typedef typename selector::template rebind<From, To> isc_binder;
   typedef typename isc_binder::type type;
};

template <typename From, typename To>
struct is_convertible_impl_dispatch
   : public is_convertible_impl_dispatch_base<From, To>::type
{};
# 394 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
    template<> struct is_convertible_impl< void,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const volatile > { static const bool value = (true); };
# 404 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
template< typename To > struct is_convertible_impl< void,To > { static const bool value = (false); };
template< typename From > struct is_convertible_impl< From,void > { static const bool value = (true); };

template< typename To > struct is_convertible_impl< void const,To > { static const bool value = (false); };
template< typename To > struct is_convertible_impl< void volatile,To > { static const bool value = (false); };
template< typename To > struct is_convertible_impl< void const volatile,To > { static const bool value = (false); };
template< typename From > struct is_convertible_impl< From,void const > { static const bool value = (true); };
template< typename From > struct is_convertible_impl< From,void volatile > { static const bool value = (true); };
template< typename From > struct is_convertible_impl< From,void const volatile > { static const bool value = (true); };



}

template< typename From, typename To > struct is_convertible : ::boost::integral_constant<bool,(::boost::detail::is_convertible_impl_dispatch<From,To>::value)> { };







}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 429 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp" 2
# 13 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp" 2
# 32 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 33 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp" 2

namespace boost {

namespace detail {


template <typename T>
struct empty_helper_t1 : public T
{
    empty_helper_t1();
    int i[256];
private:

   empty_helper_t1(const empty_helper_t1&);
   empty_helper_t1& operator=(const empty_helper_t1&);
};

struct empty_helper_t2 { int i[256]; };



template <typename T, bool is_a_class = false>
struct empty_helper
{
    static const bool value = false;
};

template <typename T>
struct empty_helper<T, true>
{
    static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2))

         ;
};

template <typename T>
struct is_empty_impl
{
    typedef typename remove_cv<T>::type cvt;
    static const bool value = ( ::boost::type_traits::ice_or< ::boost::detail::empty_helper<cvt,::boost::is_class<T>::value>::value , __is_empty(cvt) >::value )





              ;
};
# 195 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp"
template<> struct is_empty_impl< void > { static const bool value = (false); };

template<> struct is_empty_impl< void const > { static const bool value = (false); };
template<> struct is_empty_impl< void volatile > { static const bool value = (false); };
template<> struct is_empty_impl< void const volatile > { static const bool value = (false); };


}

template< typename T > struct is_empty : ::boost::integral_constant<bool,::boost::detail::is_empty_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 209 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp" 2
# 28 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_object.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/is_object.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/false_result.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/false_result.hpp"
namespace boost {
namespace type_traits {


struct false_result
{
    template <typename T> struct result_
    {
        static const bool value = false;
    };
};

}}
# 16 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp" 2



# 1 "/usr/include/boost-1_42/boost/type_traits/detail/is_function_ptr_helper.hpp" 1
# 26 "/usr/include/boost-1_42/boost/type_traits/detail/is_function_ptr_helper.hpp"
namespace boost {
namespace type_traits {

template <class R>
struct is_function_ptr_helper
{
    static const bool value = false;
};




template <class R >
struct is_function_ptr_helper<R (*)()> { static const bool value = true; };

template <class R >
struct is_function_ptr_helper<R (*)( ...)> { static const bool value = true; };

template <class R , class T0>
struct is_function_ptr_helper<R (*)( T0)> { static const bool value = true; };

template <class R , class T0>
struct is_function_ptr_helper<R (*)( T0 ...)> { static const bool value = true; };

template <class R , class T0 , class T1>
struct is_function_ptr_helper<R (*)( T0 , T1)> { static const bool value = true; };

template <class R , class T0 , class T1>
struct is_function_ptr_helper<R (*)( T0 , T1 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)> { static const bool value = true; };
# 203 "/usr/include/boost-1_42/boost/type_traits/detail/is_function_ptr_helper.hpp"
}
}
# 20 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp" 2






# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 27 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp" 2







namespace boost {



namespace detail {


template<bool is_ref = true>
struct is_function_chooser
    : ::boost::type_traits::false_result
{
};

template <>
struct is_function_chooser<false>
{
    template< typename T > struct result_
        : ::boost::type_traits::is_function_ptr_helper<T*>
    {
    };
};

template <typename T>
struct is_function_impl
    : is_function_chooser< ::boost::is_reference<T>::value >
        ::template result_<T>
{
};
# 90 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp"
}






template< typename T > struct is_function : ::boost::integral_constant<bool,::boost::detail::is_function_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 102 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp" 2
# 15 "/usr/include/boost-1_42/boost/type_traits/is_object.hpp" 2





# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 21 "/usr/include/boost-1_42/boost/type_traits/is_object.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct is_object_impl
{

   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_function<T>::value>::value >::value)




                ;







};

}

template< typename T > struct is_object : ::boost::integral_constant<bool,::boost::detail::is_object_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 52 "/usr/include/boost-1_42/boost/type_traits/is_object.hpp" 2
# 29 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2


# 1 "/usr/include/boost-1_42/boost/type_traits/is_stateless.hpp" 1
# 21 "/usr/include/boost-1_42/boost/type_traits/is_stateless.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/is_stateless.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct is_stateless_impl
{
  static const bool value = (::boost::type_traits::ice_and< ::boost::has_trivial_constructor<T>::value, ::boost::has_trivial_copy<T>::value, ::boost::has_trivial_destructor<T>::value, ::boost::is_class<T>::value, ::boost::is_empty<T>::value >::value)






               ;
};

}

template< typename T > struct is_stateless : ::boost::integral_constant<bool,::boost::detail::is_stateless_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 47 "/usr/include/boost-1_42/boost/type_traits/is_stateless.hpp" 2
# 32 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
# 12 "/usr/include/boost-1_42/boost/python/detail/borrowed_ptr.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/tag.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/tag.hpp"
namespace boost { namespace python {



enum tag_t { tag };

}}
# 14 "/usr/include/boost-1_42/boost/python/detail/borrowed_ptr.hpp" 2

namespace boost { namespace python { namespace detail {

template<class T> class borrowed
{
    typedef T type;
};


template<typename T>
struct is_borrowed_ptr
{
    static const bool value = false;
};


template<typename T>
struct is_borrowed_ptr<borrowed<T>*>
{
    static const bool value = true;
};

template<typename T>
struct is_borrowed_ptr<borrowed<T> const*>
{
    static const bool value = true;
};

template<typename T>
struct is_borrowed_ptr<borrowed<T> volatile*>
{
    static const bool value = true;
};

template<typename T>
struct is_borrowed_ptr<borrowed<T> const volatile*>
{
    static const bool value = true;
};
# 101 "/usr/include/boost-1_42/boost/python/detail/borrowed_ptr.hpp"
}

template <class T>
inline T* get_managed_object(detail::borrowed<T> const volatile* p, tag_t)
{
    return (T*)p;
}

}}
# 10 "/usr/include/boost-1_42/boost/python/borrowed.hpp" 2

namespace boost { namespace python {

template <class T>
inline python::detail::borrowed<T>* borrowed(T* p)
{
    return (detail::borrowed<T>*)p;
}

}}
# 13 "/usr/include/boost-1_42/boost/python/handle.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/handle_fwd.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/handle_fwd.hpp"
namespace boost { namespace python {

template <class T = PyObject> class handle;

}}
# 14 "/usr/include/boost-1_42/boost/python/handle.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/refcount.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/refcount.hpp"
namespace boost { namespace python {

template <class T>
inline T* incref(T* p)
{
    ( ((PyObject*)(python::upcast<PyObject>(p)))->ob_refcnt++);
    return p;
}

template <class T>
inline T* xincref(T* p)
{
    if ((python::upcast<PyObject>(p)) == __null) ; else ( ((PyObject*)(python::upcast<PyObject>(p)))->ob_refcnt++);
    return p;
}

template <class T>
inline void decref(T* p)
{
    if ( --((PyObject*)(python::upcast<PyObject>(p)))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(python::upcast<PyObject>(p))))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(python::upcast<PyObject>(p)))));
}

template <class T>
inline void xdecref(T* p)
{
    if ((python::upcast<PyObject>(p)) == __null) ; else if ( --((PyObject*)(python::upcast<PyObject>(p)))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(python::upcast<PyObject>(p))))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(python::upcast<PyObject>(p)))));
}

}}
# 15 "/usr/include/boost-1_42/boost/python/handle.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/detail/raw_pyobject.hpp" 1







namespace boost { namespace python { namespace detail {
# 19 "/usr/include/boost-1_42/boost/python/detail/raw_pyobject.hpp"
struct new_reference_t;
typedef new_reference_t* new_reference;


struct borrowed_reference_t;
typedef borrowed_reference_t* borrowed_reference;


struct new_non_null_reference_t;
typedef new_non_null_reference_t* new_non_null_reference;

}}}
# 17 "/usr/include/boost-1_42/boost/python/handle.hpp" 2

namespace boost { namespace python {

template <class T> struct null_ok;

template <class T>
inline null_ok<T>* allow_null(T* p)
{
    return (null_ok<T>*)p;
}

namespace detail
{
  template <class T>
  inline T* manage_ptr(detail::borrowed<null_ok<T> >* p, int)
  {
      return python::xincref((T*)p);
  }

  template <class T>
  inline T* manage_ptr(null_ok<detail::borrowed<T> >* p, int)
  {
      return python::xincref((T*)p);
  }

  template <class T>
  inline T* manage_ptr(detail::borrowed<T>* p, long)
  {
      return python::incref(expect_non_null((T*)p));
  }

  template <class T>
  inline T* manage_ptr(null_ok<T>* p, long)
  {
      return (T*)p;
  }

  template <class T>
  inline T* manage_ptr(T* p, ...)
  {
      return expect_non_null(p);
  }
}

template <class T>
class handle
{
    typedef T* (handle::* bool_type )() const;

 public:
    typedef T element_type;

 public:
    handle();
    ~handle();

    template <class Y>
    explicit handle(Y* p)
        : m_p(
            python::upcast<T>(
                detail::manage_ptr(p, 0)
                )
            )
    {
    }

    handle& operator=(handle const& r)
    {
        python::xdecref(m_p);
        m_p = python::xincref(r.m_p);
        return *this;
    }



    template<typename Y>
    handle& operator=(handle<Y> const & r)
    {
        python::xdecref(m_p);
        m_p = python::xincref(python::upcast<T>(r.get()));
        return *this;
    }



    template <typename Y>
    handle(handle<Y> const& r)
        : m_p(python::xincref(python::upcast<T>(r.get())))
    {
    }

    handle(handle const& r)
        : m_p(python::xincref(r.m_p))
    {
    }

    T* operator-> () const;
    T& operator* () const;
    T* get() const;
    T* release();
    void reset();

    operator bool_type() const
    {
        return m_p ? &handle<T>::get : 0;
    }
    bool operator! () const;

 public:

    inline handle(detail::borrowed_reference x)
        : m_p(
            python::incref(
                downcast<T>((PyObject*)x)
                ))
    {
    }

 private:
    T* m_p;
};





template<class T> inline T * get_pointer(python::handle<T> const & p)
{
    return p.get();
}






using boost::get_pointer;



typedef handle<PyTypeObject> type_handle;





template<typename T>
class is_handle
{
 public:
    static const bool value = false;
};

template<typename T>
class is_handle<handle<T> >
{
 public:
    static const bool value = true;
};
# 202 "/usr/include/boost-1_42/boost/python/handle.hpp"
template <class T>
inline handle<T>::handle()
    : m_p(0)
{
}

template <class T>
inline handle<T>::~handle()
{
    python::xdecref(m_p);
}

template <class T>
inline T* handle<T>::operator->() const
{
    return m_p;
}

template <class T>
inline T& handle<T>::operator*() const
{
    return *m_p;
}

template <class T>
inline T* handle<T>::get() const
{
    return m_p;
}

template <class T>
inline bool handle<T>::operator!() const
{
    return m_p == 0;
}

template <class T>
inline T* handle<T>::release()
{
    T* result = m_p;
    m_p = 0;
    return result;
}

template <class T>
inline void handle<T>::reset()
{
    python::xdecref(m_p);
    m_p = 0;
}



template <class T>
inline PyObject* get_managed_object(handle<T> const& h, tag_t)
{
    return h.get() ? python::upcast<PyObject>(h.get()) : (&_Py_NoneStruct);
}

}}
# 11 "/usr/include/boost-1_42/boost/python/args_fwd.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 13 "/usr/include/boost-1_42/boost/python/args_fwd.hpp" 2


namespace boost { namespace python {

namespace detail
{
  struct keyword
  {
      keyword(char const* name_=0)
       : name(name_)
      {}

      char const* name;
      handle<> default_value;
  };

  template <std::size_t nkeywords = 0> struct keywords;

  typedef std::pair<keyword const*, keyword const*> keyword_range;

  template <>
  struct keywords<0>
  {
      static const std::size_t size = 0;
      static keyword_range range() { return keyword_range(); }
  };

  namespace error
  {
    template <int keywords, int function_args>
    struct more_keywords_than_function_arguments
    {
        typedef char too_many_keywords[keywords > function_args ? -1 : 1];
    };
  }
}

}}
# 11 "/usr/include/boost-1_42/boost/python/args.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/detail/preprocessor.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/args.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/type_list.hpp" 1
# 28 "/usr/include/boost-1_42/boost/python/detail/type_list.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/vector/vector20.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/vector/vector20.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/vector/vector10.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/vector/vector10.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/at_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/at_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct at_impl;
template< typename Sequence, typename N > struct at;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/tag.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/tag.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/typeof.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/tag.hpp" 2


namespace boost { namespace mpl { namespace aux {

struct v_iter_tag;


struct vector_tag;




}}}
# 19 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/long.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/long.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/long_fwd.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/long_fwd.hpp"
namespace mpl_ {

template< long N > struct long_;

}
namespace boost { namespace mpl { using ::mpl_::long_; } }
# 18 "/usr/include/boost-1_42/boost/mpl/long.hpp" 2


# 1 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 1
# 40 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
namespace mpl_ {

template< long N >
struct long_
{
    static const long value = N;





    typedef long_ type;

    typedef long value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
    typedef mpl_::long_< static_cast<long>((value + 1)) > next;
    typedef mpl_::long_< static_cast<long>((value - 1)) > prior;






    operator long() const { return static_cast<long>(this->value); }
};


template< long N >
long const mpl_::long_< N >::value;


}
# 21 "/usr/include/boost-1_42/boost/mpl/long.hpp" 2
# 20 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/void.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/void.hpp"
namespace mpl_ {





struct void_ { typedef void_ type; };

}

namespace boost { namespace mpl {

template< typename T >
struct is_void_
    : false_
{



};

template<>
struct is_void_<void_>
    : true_
{



};

template< typename T >
struct is_not_void_
    : true_
{



};

template<>
struct is_not_void_<void_>
    : false_
{



};

template<> struct is_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_void_< T1 > { }; }; template< typename Tag > struct lambda< is_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_void_< na > result_; typedef is_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_void_< na > > : int_<-1> { }; }
template<> struct is_not_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_not_void_< T1 > { }; }; template< typename Tag > struct lambda< is_not_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_not_void_< na > result_; typedef is_not_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_not_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_not_void_< na > > : int_<-1> { }; }

}}
# 21 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/aux_/type_wrapper.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/type_wrapper.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename T > struct type_wrapper
{
    typedef T type;
};






template< typename T > struct wrapped_type;

template< typename T > struct wrapped_type< type_wrapper<T> >
{
    typedef T type;
};







}}}
# 23 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 2




namespace boost { namespace mpl {



template< typename Vector, long n_ >
struct v_at_impl
{
    typedef long_< (Vector::lower_bound_::value + n_) > index_;
    typedef __typeof__( Vector::item_(index_()) ) type;
};


template< typename Vector, long n_ >
struct v_at
    : aux::wrapped_type< typename v_at_impl<Vector,n_>::type >
{
};

template<>
struct at_impl< aux::vector_tag >
{
    template< typename Vector, typename N > struct apply
        : v_at<
              Vector
            , N::value
            >
    {
    };
};
# 114 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp"
}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/front.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/front.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/front_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/front_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct front_impl;
template< typename Sequence > struct front;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/front.hpp" 2






namespace boost { namespace mpl {



template<>
struct front_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : v_at<Vector,0>
    {
    };
};
# 54 "/usr/include/boost-1_42/boost/mpl/vector/aux_/front.hpp"
}}
# 19 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_front.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_front.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/push_front_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/push_front_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct push_front_impl;
template< typename Sequence, typename T > struct push_front;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_front.hpp" 2




# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/item.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/vector/aux_/item.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/next_prior.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/next_prior.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/common_name_wknd.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/next_prior.hpp" 2



namespace boost { namespace mpl {




template<
      typename T = na
    >
struct next
{
    typedef typename T::next type;
   
};

template<
      typename T = na
    >
struct prior
{
    typedef typename T::prior type;
   
};

template<> struct next< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : next< T1 > { }; }; template< typename Tag > struct lambda< next< na > , Tag , int_<-1> > { typedef false_ is_le; typedef next< na > result_; typedef next< na > type; }; namespace aux { template< typename T1 > struct template_arity< next< T1 > > : int_<1> { }; template<> struct template_arity< next< na > > : int_<-1> { }; }
template<> struct prior< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : prior< T1 > { }; }; template< typename Tag > struct lambda< prior< na > , Tag , int_<-1> > { typedef false_ is_le; typedef prior< na > result_; typedef prior< na > type; }; namespace aux { template< typename T1 > struct template_arity< prior< T1 > > : int_<1> { }; template<> struct template_arity< prior< na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_42/boost/mpl/vector/aux_/item.hpp" 2




namespace boost { namespace mpl {



template<
      typename T
    , typename Base
    , int at_front = 0
    >
struct v_item
    : Base
{
    typedef typename Base::upper_bound_ index_;
    typedef typename next<index_>::type upper_bound_;
    typedef typename next<typename Base::size>::type size;
    typedef Base base;
    typedef v_item type;



    static aux::type_wrapper<T> item_(index_);
    using Base::item_;
};

template<
      typename T
    , typename Base
    >
struct v_item<T,Base,1>
    : Base
{
    typedef typename prior<typename Base::lower_bound_>::type index_;
    typedef index_ lower_bound_;
    typedef typename next<typename Base::size>::type size;
    typedef Base base;
    typedef v_item type;

    static aux::type_wrapper<T> item_(index_);
    using Base::item_;
};


template<
      typename Base
    , int at_front
    >
struct v_mask
    : Base
{
    typedef typename prior<typename Base::upper_bound_>::type index_;
    typedef index_ upper_bound_;
    typedef typename prior<typename Base::size>::type size;
    typedef Base base;
    typedef v_mask type;

    static aux::type_wrapper<void_> item_(index_);
    using Base::item_;
};

template<
      typename Base
    >
struct v_mask<Base,1>
    : Base
{
    typedef typename Base::lower_bound_ index_;
    typedef typename next<index_>::type lower_bound_;
    typedef typename prior<typename Base::size>::type size;
    typedef Base base;
    typedef v_mask type;

    static aux::type_wrapper<void_> item_(index_);
    using Base::item_;
};



}}
# 23 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_front.hpp" 2


namespace boost { namespace mpl {

template<>
struct push_front_impl< aux::vector_tag >
{
    template< typename Vector, typename T > struct apply
    {
        typedef v_item<T,Vector,1> type;
    };
};

}}
# 20 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_front.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_front.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/pop_front_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/pop_front_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct pop_front_impl;
template< typename Sequence > struct pop_front;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_front.hpp" 2







namespace boost { namespace mpl {

template<>
struct pop_front_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_mask<Vector,1> type;
    };
};

}}
# 21 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_back.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_back.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/push_back_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/push_back_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct push_back_impl;
template< typename Sequence, typename T > struct push_back;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_back.hpp" 2







namespace boost { namespace mpl {

template<>
struct push_back_impl< aux::vector_tag >
{
    template< typename Vector, typename T > struct apply
    {
        typedef v_item<T,Vector,0> type;
    };
};

}}
# 22 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_back.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_back.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/pop_back_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/pop_back_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct pop_back_impl;
template< typename Sequence > struct pop_back;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_back.hpp" 2







namespace boost { namespace mpl {

template<>
struct pop_back_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_mask<Vector,0> type;
    };
};

}}
# 23 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/back.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/back.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/back_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/back_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct back_impl;
template< typename Sequence > struct back;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/back.hpp" 2






namespace boost { namespace mpl {



template<>
struct back_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : v_at<
              Vector
            , prior<typename Vector::size>::type::value
            >
    {
    };
};
# 57 "/usr/include/boost-1_42/boost/mpl/vector/aux_/back.hpp"
}}
# 24 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/clear.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/clear.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/clear_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/clear_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct clear_impl;
template< typename Sequence > struct clear;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/clear.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/vector0.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/vector/aux_/vector0.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/iterator_tags.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/iterator_tags.hpp"
namespace boost { namespace mpl {

struct forward_iterator_tag : int_<0> { typedef forward_iterator_tag type; };
struct bidirectional_iterator_tag : int_<1> { typedef bidirectional_iterator_tag type; };
struct random_access_iterator_tag : int_<2> { typedef random_access_iterator_tag type; };

}}
# 19 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/plus.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/plus.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/largest_int.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/largest_int.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename T > struct integral_rank;

template<> struct integral_rank<bool> : int_<1> {};
template<> struct integral_rank<signed char> : int_<2> {};
template<> struct integral_rank<char> : int_<3> {};
template<> struct integral_rank<unsigned char> : int_<4> {};

template<> struct integral_rank<wchar_t> : int_<5> {};

template<> struct integral_rank<short> : int_<6> {};
template<> struct integral_rank<unsigned short> : int_<7> {};
template<> struct integral_rank<int> : int_<8> {};
template<> struct integral_rank<unsigned int> : int_<9> {};
template<> struct integral_rank<long> : int_<10> {};
template<> struct integral_rank<unsigned long> : int_<11> {};


template<> struct integral_rank<long_long_type> : int_<12> {};
template<> struct integral_rank<ulong_long_type>: int_<13> {};


template< typename T1, typename T2 > struct largest_int

    : if_c<
          ( integral_rank<T1>::value >= integral_rank<T2>::value )
        , T1
        , T2
        >
{






};

}}}
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2







# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 1
# 21 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/numeric_cast.hpp" 1
# 30 "/usr/include/boost-1_42/boost/mpl/numeric_cast.hpp"
namespace boost { namespace mpl {



template< typename SourceTag, typename TargetTag > struct numeric_cast
{
    template< typename N > struct apply;
};

}}
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/has_apply.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/has_apply.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/has_xxx.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/has_xxx.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/yes_no.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/yes_no.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/arrays.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/yes_no.hpp" 2




namespace boost { namespace mpl { namespace aux {

typedef char (&no_tag)[1];
typedef char (&yes_tag)[2];

template< bool C_ > struct yes_no_tag
{
    typedef no_tag type;
};

template<> struct yes_no_tag<true>
{
    typedef yes_tag type;
};


template< long n > struct weighted_tag
{

    typedef char (&type)[n];




};
# 56 "/usr/include/boost-1_42/boost/mpl/aux_/yes_no.hpp"
}}}
# 21 "/usr/include/boost-1_42/boost/mpl/has_xxx.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/has_xxx.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/has_xxx.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/msvc_typename.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/has_xxx.hpp" 2
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/has_apply.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/has_apply.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/has_apply.hpp" 2

namespace boost { namespace mpl { namespace aux {

template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_apply { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::apply>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };







}}}
# 24 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_never_true.hpp" 1
# 26 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 2


# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/use_preprocessed.hpp" 1
# 29 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 2





# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 16 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/compiler.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2



# 1 "/usr/include/boost-1_42/boost/preprocessor/stringize.hpp" 1
# 21 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp"
namespace boost { namespace mpl {

template<
      typename F

    , typename has_apply_ = typename aux::has_apply<F>::type

    >
struct apply_wrap0

    : F::template apply< >
{
};

template< typename F >
struct apply_wrap0< F,true_ >
    : F::apply
{
};

template<
      typename F, typename T1

    >
struct apply_wrap1

    : F::template apply<T1>
{
};

template<
      typename F, typename T1, typename T2

    >
struct apply_wrap2

    : F::template apply< T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3

    >
struct apply_wrap3

    : F::template apply< T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4

    >
struct apply_wrap4

    : F::template apply< T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5

    >
struct apply_wrap5

    : F::template apply< T1,T2,T3,T4,T5 >
{
};

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 35 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 2
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/tag.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/tag.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/eval_if.hpp" 1
# 24 "/usr/include/boost-1_42/boost/mpl/eval_if.hpp"
namespace boost { namespace mpl {

template<
      typename C = na
    , typename F1 = na
    , typename F2 = na
    >
struct eval_if




{
    typedef typename if_<C,F1,F2>::type f_;
    typedef typename f_::type type;




   
};



template<
      bool C
    , typename F1
    , typename F2
    >
struct eval_if_c




{
    typedef typename if_c<C,F1,F2>::type f_;
    typedef typename f_::type type;




};

template<> struct eval_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : eval_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< eval_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef eval_if< na , na , na > result_; typedef eval_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< eval_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< eval_if< na , na , na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost-1_42/boost/mpl/tag.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/aux_/has_tag.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/has_tag.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 20 "/usr/include/boost-1_42/boost/mpl/tag.hpp" 2


namespace boost { namespace mpl {

namespace aux {
template< typename T > struct tag_impl
{
    typedef typename T::tag type;
};
}

template< typename T, typename Default = void_ > struct tag

    : if_<
          aux::has_tag<T>
        , aux::tag_impl<T>
        , Default
        >::type
{
# 48 "/usr/include/boost-1_42/boost/mpl/tag.hpp"
};

}}
# 25 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/forwarding.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp" 2

namespace boost { namespace mpl { namespace aux {

template<
      typename F
    , typename Tag1
    , typename Tag2
    >
struct cast1st_impl
{
    template< typename N1, typename N2 > struct apply

        : apply_wrap2<
              F
            , typename apply_wrap1< numeric_cast<Tag1,Tag2>,N1 >::type
            , N2
            >
    {
# 46 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp"
    };
};

template<
      typename F
    , typename Tag1
    , typename Tag2
    >
struct cast2nd_impl
{
    template< typename N1, typename N2 > struct apply

        : apply_wrap2<
              F
            , N1
            , typename apply_wrap1< numeric_cast<Tag2,Tag1>,N2 >::type
            >
    {
# 72 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp"
    };
};

}}}
# 26 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2



# 1 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_eti_base.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_eti_base.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/is_msvc_eti_arg.hpp" 1
# 21 "/usr/include/boost-1_42/boost/mpl/aux_/is_msvc_eti_arg.hpp"
namespace boost { namespace mpl { namespace aux {
# 62 "/usr/include/boost-1_42/boost/mpl/aux_/is_msvc_eti_arg.hpp"
}}}
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_eti_base.hpp" 2




namespace boost { namespace mpl { namespace aux {
# 55 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_eti_base.hpp"
template< typename T > struct msvc_eti_base
    : T
{

    msvc_eti_base();

    typedef T type;
};



template<> struct msvc_eti_base<int>
{
    typedef msvc_eti_base type;
    typedef msvc_eti_base first;
    typedef msvc_eti_base second;
    typedef msvc_eti_base tag;
    enum { value = 0 };
};

}}}
# 30 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
# 27 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2







# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/plus.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/plus.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct plus_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct plus_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct plus_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct plus_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct plus_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    , typename N3 = na, typename N4 = na, typename N5 = na
    >
struct plus
    : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5>
{
   




};

template<
      typename N1, typename N2, typename N3, typename N4
    >
struct plus< N1,N2,N3,N4,na >

    : plus< plus< plus< N1,N2 >, N3>, N4>
{
   




};

template<
      typename N1, typename N2, typename N3
    >
struct plus< N1,N2,N3,na,na >

    : plus< plus< N1,N2 >, N3>
{
   




};

template<
      typename N1, typename N2
    >
struct plus< N1,N2,na,na,na >
    : plus_impl<
          typename plus_tag<N1>::type
        , typename plus_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   





};

template<> struct plus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : plus< T1 , T2 > { }; }; template< typename Tag > struct lambda< plus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef plus< na , na > result_; typedef plus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< plus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< plus< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {
template<>
struct plus_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : integral_c<
              typename aux::largest_int<
                  typename N1::value_type
                , typename N2::value_type
                >::type
            , ( N1::value
                  + N2::value
                )
            >
    {
    };
};

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 35 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2
# 20 "/usr/include/boost-1_42/boost/mpl/plus.hpp" 2
# 20 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/minus.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/minus.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 1
# 26 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
# 27 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2







# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/minus.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/minus.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct minus_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct minus_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct minus_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct minus_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct minus_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    , typename N3 = na, typename N4 = na, typename N5 = na
    >
struct minus
    : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5>
{
   




};

template<
      typename N1, typename N2, typename N3, typename N4
    >
struct minus< N1,N2,N3,N4,na >

    : minus< minus< minus< N1,N2 >, N3>, N4>
{
   




};

template<
      typename N1, typename N2, typename N3
    >
struct minus< N1,N2,N3,na,na >

    : minus< minus< N1,N2 >, N3>
{
   




};

template<
      typename N1, typename N2
    >
struct minus< N1,N2,na,na,na >
    : minus_impl<
          typename minus_tag<N1>::type
        , typename minus_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   





};

template<> struct minus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : minus< T1 , T2 > { }; }; template< typename Tag > struct lambda< minus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef minus< na , na > result_; typedef minus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< minus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< minus< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {
template<>
struct minus_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : integral_c<
              typename aux::largest_int<
                  typename N1::value_type
                , typename N2::value_type
                >::type
            , ( N1::value
                  - N2::value
                )
            >
    {
    };
};

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 35 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2
# 20 "/usr/include/boost-1_42/boost/mpl/minus.hpp" 2
# 21 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/advance_fwd.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/advance_fwd.hpp"
namespace boost { namespace mpl {



template< typename Tag > struct advance_impl;
template< typename Iterator, typename N > struct advance;

}}
# 22 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/distance_fwd.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/distance_fwd.hpp"
namespace boost { namespace mpl {



template< typename Tag > struct distance_impl;
template< typename First, typename Last > struct distance;

}}
# 23 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/next.hpp" 1
# 24 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/prior.hpp" 1
# 25 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2





namespace boost { namespace mpl {

template<
      typename Vector
    , long n_
    >
struct v_iter
{
    typedef aux::v_iter_tag tag;
    typedef random_access_iterator_tag category;
    typedef typename v_at<Vector,n_>::type type;

    typedef Vector vector_;
    typedef mpl::long_<n_> pos;
# 56 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp"
};




template<
      typename Vector
    , long n_
    >
struct next< v_iter<Vector,n_> >
{
    typedef v_iter<Vector,(n_ + 1)> type;
};

template<
      typename Vector
    , long n_
    >
struct prior< v_iter<Vector,n_> >
{
    typedef v_iter<Vector,(n_ - 1)> type;
};

template<
      typename Vector
    , long n_
    , typename Distance
    >
struct advance< v_iter<Vector,n_>,Distance>
{
    typedef v_iter<
          Vector
        , (n_ + Distance::value)
        > type;
};

template<
      typename Vector
    , long n_
    , long m_
    >
struct distance< v_iter<Vector,n_>, v_iter<Vector,m_> >
    : mpl::long_<(m_ - n_)>
{
};
# 128 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp"
}}
# 23 "/usr/include/boost-1_42/boost/mpl/vector/aux_/vector0.hpp" 2



namespace boost { namespace mpl {

template< typename Dummy = na > struct vector0;

template<> struct vector0<na>
{

    typedef aux::vector_tag tag;
    typedef vector0 type;
    typedef long_<32768> lower_bound_;
    typedef lower_bound_ upper_bound_;
    typedef long_<0> size;

    static aux::type_wrapper<void_> item_(...);
# 48 "/usr/include/boost-1_42/boost/mpl/vector/aux_/vector0.hpp"
};

}}
# 19 "/usr/include/boost-1_42/boost/mpl/vector/aux_/clear.hpp" 2




namespace boost { namespace mpl {



template<>
struct clear_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef vector0<> type;
    };
};
# 53 "/usr/include/boost-1_42/boost/mpl/vector/aux_/clear.hpp"
}}
# 25 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/O1_size.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/O1_size.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/O1_size_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/O1_size_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct O1_size_impl;
template< typename Sequence > struct O1_size;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/O1_size.hpp" 2






namespace boost { namespace mpl {



template<>
struct O1_size_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : Vector::size
    {
    };
};
# 54 "/usr/include/boost-1_42/boost/mpl/vector/aux_/O1_size.hpp"
}}
# 26 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/size.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/size.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/size_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/size_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct size_impl;
template< typename Sequence > struct size;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/size.hpp" 2





namespace boost { namespace mpl {



template<>
struct size_impl< aux::vector_tag >
    : O1_size_impl< aux::vector_tag >
{
};
# 47 "/usr/include/boost-1_42/boost/mpl/vector/aux_/size.hpp"
}}
# 27 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/empty.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/empty.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/empty_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/empty_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct empty_impl;
template< typename Sequence > struct empty;

}}
# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/empty.hpp" 2






namespace boost { namespace mpl {



template<>
struct empty_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : is_same<
              typename Vector::lower_bound_
            , typename Vector::upper_bound_
            >
    {
    };
};
# 66 "/usr/include/boost-1_42/boost/mpl/vector/aux_/empty.hpp"
}}
# 28 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2



# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/begin_end.hpp" 1
# 21 "/usr/include/boost-1_42/boost/mpl/vector/aux_/begin_end.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/begin_end_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/begin_end_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct begin_impl;
template< typename Tag > struct end_impl;

template< typename Sequence > struct begin;
template< typename Sequence > struct end;

}}
# 22 "/usr/include/boost-1_42/boost/mpl/vector/aux_/begin_end.hpp" 2



namespace boost { namespace mpl {

template<>
struct begin_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_iter<Vector,0> type;
    };
};

template<>
struct end_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_iter<Vector,Vector::size::value> type;
    };
};

}}
# 32 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
# 19 "/usr/include/boost-1_42/boost/mpl/vector/vector10.hpp" 2
# 27 "/usr/include/boost-1_42/boost/mpl/vector/vector10.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp" 1
# 49 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp"
namespace boost { namespace mpl {

template<
      typename T0
    >
struct vector1
    : v_item<
          T0
        , vector0< >
        >
{
    typedef vector1 type;
};

template<
      typename T0, typename T1
    >
struct vector2
    : v_item<
          T1
        , vector1<T0>
        >
{
    typedef vector2 type;
};

template<
      typename T0, typename T1, typename T2
    >
struct vector3
    : v_item<
          T2
        , vector2< T0,T1 >
        >
{
    typedef vector3 type;
};

template<
      typename T0, typename T1, typename T2, typename T3
    >
struct vector4
    : v_item<
          T3
        , vector3< T0,T1,T2 >
        >
{
    typedef vector4 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    >
struct vector5
    : v_item<
          T4
        , vector4< T0,T1,T2,T3 >
        >
{
    typedef vector5 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct vector6
    : v_item<
          T5
        , vector5< T0,T1,T2,T3,T4 >
        >
{
    typedef vector6 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6
    >
struct vector7
    : v_item<
          T6
        , vector6< T0,T1,T2,T3,T4,T5 >
        >
{
    typedef vector7 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7
    >
struct vector8
    : v_item<
          T7
        , vector7< T0,T1,T2,T3,T4,T5,T6 >
        >
{
    typedef vector8 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8
    >
struct vector9
    : v_item<
          T8
        , vector8< T0,T1,T2,T3,T4,T5,T6,T7 >
        >
{
    typedef vector9 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    >
struct vector10
    : v_item<
          T9
        , vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
        >
{
    typedef vector10 type;
};

}}
# 50 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp" 2
# 28 "/usr/include/boost-1_42/boost/mpl/vector/vector10.hpp" 2
# 19 "/usr/include/boost-1_42/boost/mpl/vector/vector20.hpp" 2
# 27 "/usr/include/boost-1_42/boost/mpl/vector/vector20.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp" 1
# 49 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp"
namespace boost { namespace mpl {

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10
    >
struct vector11
    : v_item<
          T10
        , vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
        >
{
    typedef vector11 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11
    >
struct vector12
    : v_item<
          T11
        , vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
        >
{
    typedef vector12 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12
    >
struct vector13
    : v_item<
          T12
        , vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
        >
{
    typedef vector13 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13
    >
struct vector14
    : v_item<
          T13
        , vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
        >
{
    typedef vector14 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    >
struct vector15
    : v_item<
          T14
        , vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
        >
{
    typedef vector15 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15
    >
struct vector16
    : v_item<
          T15
        , vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >
        >
{
    typedef vector16 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16
    >
struct vector17
    : v_item<
          T16
        , vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >
        >
{
    typedef vector17 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17
    >
struct vector18
    : v_item<
          T17
        , vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >
        >
{
    typedef vector18 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17, typename T18
    >
struct vector19
    : v_item<
          T18
        , vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >
        >
{
    typedef vector19 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17, typename T18, typename T19
    >
struct vector20
    : v_item<
          T19
        , vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >
        >
{
    typedef vector20 type;
};

}}
# 50 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp" 2
# 28 "/usr/include/boost-1_42/boost/mpl/vector/vector20.hpp" 2
# 29 "/usr/include/boost-1_42/boost/python/detail/type_list.hpp" 2





# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/type_list.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 2


# 1 "/usr/include/boost-1_42/boost/preprocessor/enum_params_with_a_default.hpp" 1
# 15 "/usr/include/boost-1_42/boost/preprocessor/enum_params_with_a_default.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_params_with_a_default.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_params_with_a_default.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/facilities/intercept.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_params_with_a_default.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_binary_params.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_params_with_a_default.hpp" 2
# 16 "/usr/include/boost-1_42/boost/preprocessor/enum_params_with_a_default.hpp" 2
# 13 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 2



# 1 "/usr/include/boost-1_42/boost/preprocessor/iterate.hpp" 1
# 15 "/usr/include/boost-1_42/boost/preprocessor/iterate.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/iterate.hpp" 1
# 17 "/usr/include/boost-1_42/boost/preprocessor/iteration/iterate.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/array/elem.hpp" 1
# 15 "/usr/include/boost-1_42/boost/preprocessor/array/elem.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/array/data.hpp" 1
# 16 "/usr/include/boost-1_42/boost/preprocessor/array/elem.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/array/size.hpp" 1
# 17 "/usr/include/boost-1_42/boost/preprocessor/array/elem.hpp" 2
# 18 "/usr/include/boost-1_42/boost/preprocessor/iteration/iterate.hpp" 2


# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/slot.hpp" 1
# 16 "/usr/include/boost-1_42/boost/preprocessor/slot/slot.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/def.hpp" 1
# 17 "/usr/include/boost-1_42/boost/preprocessor/slot/slot.hpp" 2
# 21 "/usr/include/boost-1_42/boost/preprocessor/iteration/iterate.hpp" 2
# 16 "/usr/include/boost-1_42/boost/preprocessor/iterate.hpp" 2
# 17 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_trailing.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_trailing.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_trailing.hpp" 2
# 18 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 2

namespace boost { namespace python { namespace detail {

template < class T0 = mpl::void_ , class T1 = mpl::void_ , class T2 = mpl::void_ , class T3 = mpl::void_ , class T4 = mpl::void_ , class T5 = mpl::void_ , class T6 = mpl::void_ , class T7 = mpl::void_ , class T8 = mpl::void_ , class T9 = mpl::void_ , class T10 = mpl::void_ , class T11 = mpl::void_ , class T12 = mpl::void_ , class T13 = mpl::void_ , class T14 = mpl::void_ , class T15 = mpl::void_ , class T16 = mpl::void_ >
struct type_list
    : mpl::vector17< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16>
{
};



# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
   
    >
struct type_list<
   
   
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector0<>
{
};
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0
    >
struct type_list<
    T0
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector1< T0>
{
};
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1
    >
struct type_list<
    T0 , T1
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector2< T0 , T1>
{
};
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2
    >
struct type_list<
    T0 , T1 , T2
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector3< T0 , T1 , T2>
{
};
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3
    >
struct type_list<
    T0 , T1 , T2 , T3
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector4< T0 , T1 , T2 , T3>
{
};
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector5< T0 , T1 , T2 , T3 , T4>
{
};
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector6< T0 , T1 , T2 , T3 , T4 , T5>
{
};
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5 , T6
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector7< T0 , T1 , T2 , T3 , T4 , T5 , T6>
{
};
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector8< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
{
};
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector9< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
{
};
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector10< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
{
};
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector11< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
{
};
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector12< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
{
};
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector13< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
{
};
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
    ,
   
 mpl::void_ , mpl::void_ , mpl::void_
    >
   : mpl::vector14< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
{
};
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
    ,
   
 mpl::void_ , mpl::void_
    >
   : mpl::vector15< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
{
};
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
template <
    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15
    >
struct type_list<
    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15
    ,
   
 mpl::void_
    >
   : mpl::vector16< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15>
{
};
# 128 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 30 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 2


}}}
# 35 "/usr/include/boost-1_42/boost/python/detail/type_list.hpp" 2
# 14 "/usr/include/boost-1_42/boost/python/args.hpp" 2


# 1 "/usr/include/boost-1_42/boost/type_traits/remove_reference.hpp" 1
# 21 "/usr/include/boost-1_42/boost/type_traits/remove_reference.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/remove_reference.hpp" 2

namespace boost {



template< typename T > struct remove_reference { typedef T type; };
template< typename T > struct remove_reference<T&> { typedef T type; };
# 46 "/usr/include/boost-1_42/boost/type_traits/remove_reference.hpp"
}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 49 "/usr/include/boost-1_42/boost/type_traits/remove_reference.hpp" 2
# 17 "/usr/include/boost-1_42/boost/python/args.hpp" 2





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/local.hpp" 1
# 23 "/usr/include/boost-1_42/boost/python/args.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/detail/mpl_lambda.hpp" 1
# 25 "/usr/include/boost-1_42/boost/python/args.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object_core.hpp" 1
# 12 "/usr/include/boost-1_42/boost/python/object_core.hpp"
# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 15 "/usr/include/boost-1_42/boost/python/call.hpp"
# 1 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/ptr.hpp" 1
# 21 "/usr/include/boost-1_42/boost/python/ptr.hpp"
namespace boost { namespace python {

template<class Ptr> class pointer_wrapper
{
 public:
    typedef Ptr type;

    explicit pointer_wrapper(Ptr x): p_(x) {}
    operator Ptr() const { return p_; }
    Ptr get() const { return p_; }
 private:
    Ptr p_;
};

template<class T>
inline pointer_wrapper<T> ptr(T t)
{
    return pointer_wrapper<T>(t);
}


template<typename T>
class is_pointer_wrapper
    : public mpl::false_
{
};

template<typename T>
class is_pointer_wrapper<pointer_wrapper<T> >
    : public mpl::true_
{
};

template<typename T>
class unwrap_pointer
{
 public:
    typedef T type;
};

template<typename T>
class unwrap_pointer<pointer_wrapper<T> >
{
 public:
    typedef T type;
};
# 126 "/usr/include/boost-1_42/boost/python/ptr.hpp"
}}
# 9 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/python/instance_holder.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/instance_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/utility.hpp" 1
# 13 "/usr/include/boost-1_42/boost/utility.hpp"
# 1 "/usr/include/boost-1_42/boost/utility/base_from_member.hpp" 1
# 16 "/usr/include/boost-1_42/boost/utility/base_from_member.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat_from_to.hpp" 1
# 23 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat_from_to.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat_from_to.hpp" 2
# 17 "/usr/include/boost-1_42/boost/utility/base_from_member.hpp" 2
# 53 "/usr/include/boost-1_42/boost/utility/base_from_member.hpp"
namespace boost
{
# 65 "/usr/include/boost-1_42/boost/utility/base_from_member.hpp"
template < typename MemberType, int UniqueID = 0 >
class base_from_member
{
protected:
    MemberType member;

    base_from_member()
        : member()
        {}

   
 template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {} template < typename T0 , typename T1 > explicit base_from_member( T0 x0 , T1 x1 ) : member( x0 , x1 ) {} template < typename T0 , typename T1 , typename T2 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 ) : member( x0 , x1 , x2 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 ) : member( x0 , x1 , x2 , x3 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 ) : member( x0 , x1 , x2 , x3 , x4 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 ) : member( x0 , x1 , x2 , x3 , x4 , x5 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 , T9 x9 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 ) {}

};

}
# 14 "/usr/include/boost-1_42/boost/utility.hpp" 2
# 1 "/usr/include/boost-1_42/boost/utility/binary.hpp" 1
# 26 "/usr/include/boost-1_42/boost/utility/binary.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/control/deduce_d.hpp" 1
# 16 "/usr/include/boost-1_42/boost/preprocessor/control/deduce_d.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
# 17 "/usr/include/boost-1_42/boost/preprocessor/control/deduce_d.hpp" 2
# 27 "/usr/include/boost-1_42/boost/utility/binary.hpp" 2


# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/cat.hpp" 1
# 18 "/usr/include/boost-1_42/boost/preprocessor/seq/cat.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/fold_left.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/seq/fold_left.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/seq/fold_left.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/seq.hpp" 1
# 16 "/usr/include/boost-1_42/boost/preprocessor/seq/seq.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/elem.hpp" 1
# 17 "/usr/include/boost-1_42/boost/preprocessor/seq/seq.hpp" 2
# 21 "/usr/include/boost-1_42/boost/preprocessor/seq/fold_left.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/size.hpp" 1
# 22 "/usr/include/boost-1_42/boost/preprocessor/seq/fold_left.hpp" 2
# 19 "/usr/include/boost-1_42/boost/preprocessor/seq/cat.hpp" 2
# 30 "/usr/include/boost-1_42/boost/utility/binary.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/transform.hpp" 1
# 31 "/usr/include/boost-1_42/boost/utility/binary.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/mod.hpp" 1
# 17 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/mod.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/detail/div_base.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/detail/div_base.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/comparison/less_equal.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/comparison/less_equal.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/logical/not.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/comparison/less_equal.hpp" 2
# 20 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/detail/div_base.hpp" 2
# 18 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/mod.hpp" 2
# 32 "/usr/include/boost-1_42/boost/utility/binary.hpp" 2
# 15 "/usr/include/boost-1_42/boost/utility.hpp" 2

# 1 "/usr/include/boost-1_42/boost/checked_delete.hpp" 1
# 24 "/usr/include/boost-1_42/boost/checked_delete.hpp"
namespace boost
{



template<class T> inline void checked_delete(T * x)
{

    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
}

template<class T> inline void checked_array_delete(T * x)
{
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete [] x;
}

template<class T> struct checked_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {

        boost::checked_delete(x);
    }
};

template<class T> struct checked_array_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {
        boost::checked_array_delete(x);
    }
};

}
# 17 "/usr/include/boost-1_42/boost/utility.hpp" 2
# 1 "/usr/include/boost-1_42/boost/next_prior.hpp" 1
# 17 "/usr/include/boost-1_42/boost/next_prior.hpp"
namespace boost {
# 29 "/usr/include/boost-1_42/boost/next_prior.hpp"
template <class T>
inline T next(T x) { return ++x; }

template <class T, class Distance>
inline T next(T x, Distance n)
{
    std::advance(x, n);
    return x;
}

template <class T>
inline T prior(T x) { return --x; }

template <class T, class Distance>
inline T prior(T x, Distance n)
{
    std::advance(x, -n);
    return x;
}

}
# 18 "/usr/include/boost-1_42/boost/utility.hpp" 2
# 1 "/usr/include/boost-1_42/boost/noncopyable.hpp" 1
# 12 "/usr/include/boost-1_42/boost/noncopyable.hpp"
namespace boost {






namespace noncopyable_
{
  class noncopyable
  {
   protected:
      noncopyable() {}
      ~noncopyable() {}
   private:
      noncopyable( const noncopyable& );
      const noncopyable& operator=( const noncopyable& );
  };
}

typedef noncopyable_::noncopyable noncopyable;

}
# 19 "/usr/include/boost-1_42/boost/utility.hpp" 2
# 11 "/usr/include/boost-1_42/boost/python/instance_holder.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/type_id.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/type_id.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/msvc_typeinfo.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/type_id.hpp" 2
# 1 "/usr/include/boost-1_42/boost/operators.hpp" 1
# 84 "/usr/include/boost-1_42/boost/operators.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator.hpp" 1
# 18 "/usr/include/boost-1_42/boost/iterator.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 19 "/usr/include/boost-1_42/boost/iterator.hpp" 2


namespace boost
{
# 39 "/usr/include/boost-1_42/boost/iterator.hpp"
  namespace detail {
   template <class Category, class T, class Distance, class Pointer, class Reference>

   struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
# 51 "/usr/include/boost-1_42/boost/iterator.hpp"
  }

  template <class Category, class T, class Distance = std::ptrdiff_t,
            class Pointer = T*, class Reference = T&>
  struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};

}
# 85 "/usr/include/boost-1_42/boost/operators.hpp" 2
# 95 "/usr/include/boost-1_42/boost/operators.hpp"
namespace boost {
namespace detail {

template <typename T> class empty_base {






};

}
}
# 118 "/usr/include/boost-1_42/boost/operators.hpp"
namespace boost
{







template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct less_than_comparable2 : B
{
     friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
     friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
     friend bool operator>(const U& x, const T& y) { return y < x; }
     friend bool operator<(const U& x, const T& y) { return y > x; }
     friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
     friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
};

template <class T, class B = ::boost::detail::empty_base<T> >
struct less_than_comparable1 : B
{
     friend bool operator>(const T& x, const T& y) { return y < x; }
     friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
     friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct equality_comparable2 : B
{
     friend bool operator==(const U& y, const T& x) { return x == y; }
     friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
     friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
};

template <class T, class B = ::boost::detail::empty_base<T> >
struct equality_comparable1 : B
{
     friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
};
# 254 "/usr/include/boost-1_42/boost/operators.hpp"
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct multipliable2 : B { friend T operator *( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } friend T operator *( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv *= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct multipliable1 : B { friend T operator *( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct addable2 : B { friend T operator +( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } friend T operator +( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv += lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct addable1 : B { friend T operator +( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2 : B { friend T operator -( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct subtractable1 : B { friend T operator -( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2 : B { friend T operator /( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct dividable1 : B { friend T operator /( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2 : B { friend T operator %( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct modable1 : B { friend T operator %( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct xorable2 : B { friend T operator ^( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } friend T operator ^( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv ^= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct xorable1 : B { friend T operator ^( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct andable2 : B { friend T operator &( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } friend T operator &( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv &= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct andable1 : B { friend T operator &( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct orable2 : B { friend T operator |( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } friend T operator |( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv |= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct orable1 : B { friend T operator |( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } };







template <class T, class B = ::boost::detail::empty_base<T> >
struct incrementable : B
{
  friend T operator++(T& x, int)
  {
    incrementable_type nrv(x);
    ++x;
    return nrv;
  }
private:
  typedef T incrementable_type;
};

template <class T, class B = ::boost::detail::empty_base<T> >
struct decrementable : B
{
  friend T operator--(T& x, int)
  {
    decrementable_type nrv(x);
    --x;
    return nrv;
  }
private:
  typedef T decrementable_type;
};



template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct dereferenceable : B
{
  P operator->() const
  {
    return &*static_cast<const T&>(*this);
  }
};

template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
struct indexable : B
{
  R operator[](I n) const
  {
    return *(static_cast<const T&>(*this) + n);
  }
};
# 352 "/usr/include/boost-1_42/boost/operators.hpp"
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct left_shiftable2 : B { friend T operator <<( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct left_shiftable1 : B { friend T operator <<( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct right_shiftable2 : B { friend T operator >>( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct right_shiftable1 : B { friend T operator >>( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } };



template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct equivalent2 : B
{
  friend bool operator==(const T& x, const U& y)
  {
    return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
  }
};

template <class T, class B = ::boost::detail::empty_base<T> >
struct equivalent1 : B
{
  friend bool operator==(const T&x, const T&y)
  {
    return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
  }
};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct partially_ordered2 : B
{
  friend bool operator<=(const T& x, const U& y)
    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
  friend bool operator>=(const T& x, const U& y)
    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
  friend bool operator>(const U& x, const T& y)
    { return y < x; }
  friend bool operator<(const U& x, const T& y)
    { return y > x; }
  friend bool operator<=(const U& x, const T& y)
    { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
  friend bool operator>=(const U& x, const T& y)
    { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
};

template <class T, class B = ::boost::detail::empty_base<T> >
struct partially_ordered1 : B
{
  friend bool operator>(const T& x, const T& y)
    { return y < x; }
  friend bool operator<=(const T& x, const T& y)
    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
  friend bool operator>=(const T& x, const T& y)
    { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
};



template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct totally_ordered2
    : less_than_comparable2<T, U
    , equality_comparable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct totally_ordered1
    : less_than_comparable1<T
    , equality_comparable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct additive2
    : addable2<T, U
    , subtractable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct additive1
    : addable1<T
    , subtractable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct multiplicative2
    : multipliable2<T, U
    , dividable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct multiplicative1
    : multipliable1<T
    , dividable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct integer_multiplicative2
    : multiplicative2<T, U
    , modable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct integer_multiplicative1
    : multiplicative1<T
    , modable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct arithmetic2
    : additive2<T, U
    , multiplicative2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct arithmetic1
    : additive1<T
    , multiplicative1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct integer_arithmetic2
    : additive2<T, U
    , integer_multiplicative2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct integer_arithmetic1
    : additive1<T
    , integer_multiplicative1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct bitwise2
    : xorable2<T, U
    , andable2<T, U
    , orable2<T, U, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct bitwise1
    : xorable1<T
    , andable1<T
    , orable1<T, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct unit_steppable
    : incrementable<T
    , decrementable<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct shiftable2
    : left_shiftable2<T, U
    , right_shiftable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct shiftable1
    : left_shiftable1<T
    , right_shiftable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ring_operators2
    : additive2<T, U
    , subtractable2_left<T, U
    , multipliable2<T, U, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct ring_operators1
    : additive1<T
    , multipliable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_ring_operators2
    : ring_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_ring_operators1
    : ring_operators1<T
    , totally_ordered1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct field_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct field_operators1
    : ring_operators1<T
    , dividable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_field_operators2
    : field_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_field_operators1
    : field_operators1<T
    , totally_ordered1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct euclidian_ring_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U
    , modable2<T, U
    , modable2_left<T, U, B
      > > > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct euclidian_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidian_ring_operators2
    : totally_ordered2<T, U
    , euclidian_ring_operators2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidian_ring_operators1
    : totally_ordered1<T
    , euclidian_ring_operators1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct euclidean_ring_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U
    , modable2<T, U
    , modable2_left<T, U, B
      > > > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct euclidean_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidean_ring_operators2
    : totally_ordered2<T, U
    , euclidean_ring_operators2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidean_ring_operators1
    : totally_ordered1<T
    , euclidean_ring_operators1<T, B
      > > {};

template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct input_iteratable
    : equality_comparable1<T
    , incrementable<T
    , dereferenceable<T, P, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct output_iteratable
    : incrementable<T, B
      > {};

template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct forward_iteratable
    : input_iteratable<T, P, B
      > {};

template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct bidirectional_iteratable
    : forward_iteratable<T, P
    , decrementable<T, B
      > > {};





template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
struct random_access_iteratable
    : bidirectional_iteratable<T, P
    , less_than_comparable1<T
    , additive2<T, D
    , indexable<T, D, R, B
      > > > > {};


}
# 718 "/usr/include/boost-1_42/boost/operators.hpp"
namespace boost {


namespace detail {
  struct true_t {};
  struct false_t {};
}




template<class T> struct is_chained_base {
  typedef ::boost::detail::false_t value;
};

}
# 829 "/usr/include/boost-1_42/boost/operators.hpp"
namespace boost {

template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable : less_than_comparable2<T, U, B> {}; template<class T, class U, class B> struct less_than_comparable<T, U, B, ::boost::detail::true_t> : less_than_comparable1<T, U> {}; template <class T, class B> struct less_than_comparable<T, T, B, ::boost::detail::false_t> : less_than_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::less_than_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::less_than_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::less_than_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable : equality_comparable2<T, U, B> {}; template<class T, class U, class B> struct equality_comparable<T, U, B, ::boost::detail::true_t> : equality_comparable1<T, U> {}; template <class T, class B> struct equality_comparable<T, T, B, ::boost::detail::false_t> : equality_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equality_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equality_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equality_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multipliable : multipliable2<T, U, B> {}; template<class T, class U, class B> struct multipliable<T, U, B, ::boost::detail::true_t> : multipliable1<T, U> {}; template <class T, class B> struct multipliable<T, T, B, ::boost::detail::false_t> : multipliable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multipliable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multipliable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multipliable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct addable : addable2<T, U, B> {}; template<class T, class U, class B> struct addable<T, U, B, ::boost::detail::true_t> : addable1<T, U> {}; template <class T, class B> struct addable<T, T, B, ::boost::detail::false_t> : addable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::addable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::addable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::addable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct subtractable : subtractable2<T, U, B> {}; template<class T, class U, class B> struct subtractable<T, U, B, ::boost::detail::true_t> : subtractable1<T, U> {}; template <class T, class B> struct subtractable<T, T, B, ::boost::detail::false_t> : subtractable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::subtractable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::subtractable1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct dividable : dividable2<T, U, B> {}; template<class T, class U, class B> struct dividable<T, U, B, ::boost::detail::true_t> : dividable1<T, U> {}; template <class T, class B> struct dividable<T, T, B, ::boost::detail::false_t> : dividable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::dividable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::dividable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::dividable1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::dividable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct modable : modable2<T, U, B> {}; template<class T, class U, class B> struct modable<T, U, B, ::boost::detail::true_t> : modable1<T, U> {}; template <class T, class B> struct modable<T, T, B, ::boost::detail::false_t> : modable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::modable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::modable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::modable1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::modable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct xorable : xorable2<T, U, B> {}; template<class T, class U, class B> struct xorable<T, U, B, ::boost::detail::true_t> : xorable1<T, U> {}; template <class T, class B> struct xorable<T, T, B, ::boost::detail::false_t> : xorable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::xorable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::xorable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::xorable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct andable : andable2<T, U, B> {}; template<class T, class U, class B> struct andable<T, U, B, ::boost::detail::true_t> : andable1<T, U> {}; template <class T, class B> struct andable<T, T, B, ::boost::detail::false_t> : andable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::andable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::andable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::andable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct orable : orable2<T, U, B> {}; template<class T, class U, class B> struct orable<T, U, B, ::boost::detail::true_t> : orable1<T, U> {}; template <class T, class B> struct orable<T, T, B, ::boost::detail::false_t> : orable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::orable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::orable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::orable1<T, B> > { typedef ::boost::detail::true_t value; };

 template<class T, class B> struct is_chained_base< ::boost::incrementable<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class B> struct is_chained_base< ::boost::decrementable<T, B> > { typedef ::boost::detail::true_t value; };

 template<class T, class U, class B> struct is_chained_base< ::boost::dereferenceable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class V, class B> struct is_chained_base< ::boost::indexable<T, U, V, B> > { typedef ::boost::detail::true_t value; };

template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct left_shiftable : left_shiftable2<T, U, B> {}; template<class T, class U, class B> struct left_shiftable<T, U, B, ::boost::detail::true_t> : left_shiftable1<T, U> {}; template <class T, class B> struct left_shiftable<T, T, B, ::boost::detail::false_t> : left_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::left_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::left_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::left_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct right_shiftable : right_shiftable2<T, U, B> {}; template<class T, class U, class B> struct right_shiftable<T, U, B, ::boost::detail::true_t> : right_shiftable1<T, U> {}; template <class T, class B> struct right_shiftable<T, T, B, ::boost::detail::false_t> : right_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::right_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::right_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::right_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equivalent : equivalent2<T, U, B> {}; template<class T, class U, class B> struct equivalent<T, U, B, ::boost::detail::true_t> : equivalent1<T, U> {}; template <class T, class B> struct equivalent<T, T, B, ::boost::detail::false_t> : equivalent1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equivalent<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equivalent2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equivalent1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct partially_ordered : partially_ordered2<T, U, B> {}; template<class T, class U, class B> struct partially_ordered<T, U, B, ::boost::detail::true_t> : partially_ordered1<T, U> {}; template <class T, class B> struct partially_ordered<T, T, B, ::boost::detail::false_t> : partially_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::partially_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::partially_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::partially_ordered1<T, B> > { typedef ::boost::detail::true_t value; };

template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct totally_ordered : totally_ordered2<T, U, B> {}; template<class T, class U, class B> struct totally_ordered<T, U, B, ::boost::detail::true_t> : totally_ordered1<T, U> {}; template <class T, class B> struct totally_ordered<T, T, B, ::boost::detail::false_t> : totally_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::totally_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::totally_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::totally_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct additive : additive2<T, U, B> {}; template<class T, class U, class B> struct additive<T, U, B, ::boost::detail::true_t> : additive1<T, U> {}; template <class T, class B> struct additive<T, T, B, ::boost::detail::false_t> : additive1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::additive<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::additive2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::additive1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multiplicative : multiplicative2<T, U, B> {}; template<class T, class U, class B> struct multiplicative<T, U, B, ::boost::detail::true_t> : multiplicative1<T, U> {}; template <class T, class B> struct multiplicative<T, T, B, ::boost::detail::false_t> : multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_multiplicative : integer_multiplicative2<T, U, B> {}; template<class T, class U, class B> struct integer_multiplicative<T, U, B, ::boost::detail::true_t> : integer_multiplicative1<T, U> {}; template <class T, class B> struct integer_multiplicative<T, T, B, ::boost::detail::false_t> : integer_multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct arithmetic : arithmetic2<T, U, B> {}; template<class T, class U, class B> struct arithmetic<T, U, B, ::boost::detail::true_t> : arithmetic1<T, U> {}; template <class T, class B> struct arithmetic<T, T, B, ::boost::detail::false_t> : arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_arithmetic : integer_arithmetic2<T, U, B> {}; template<class T, class U, class B> struct integer_arithmetic<T, U, B, ::boost::detail::true_t> : integer_arithmetic1<T, U> {}; template <class T, class B> struct integer_arithmetic<T, T, B, ::boost::detail::false_t> : integer_arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct bitwise : bitwise2<T, U, B> {}; template<class T, class U, class B> struct bitwise<T, U, B, ::boost::detail::true_t> : bitwise1<T, U> {}; template <class T, class B> struct bitwise<T, T, B, ::boost::detail::false_t> : bitwise1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::bitwise<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::bitwise2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::bitwise1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class B> struct is_chained_base< ::boost::unit_steppable<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct shiftable : shiftable2<T, U, B> {}; template<class T, class U, class B> struct shiftable<T, U, B, ::boost::detail::true_t> : shiftable1<T, U> {}; template <class T, class B> struct shiftable<T, T, B, ::boost::detail::false_t> : shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ring_operators : ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ring_operators<T, U, B, ::boost::detail::true_t> : ring_operators1<T, U> {}; template <class T, class B> struct ring_operators<T, T, B, ::boost::detail::false_t> : ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_ring_operators : ordered_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_ring_operators1<T, U> {}; template <class T, class B> struct ordered_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct field_operators : field_operators2<T, U, B> {}; template<class T, class U, class B> struct field_operators<T, U, B, ::boost::detail::true_t> : field_operators1<T, U> {}; template <class T, class B> struct field_operators<T, T, B, ::boost::detail::false_t> : field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_field_operators : ordered_field_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_field_operators<T, U, B, ::boost::detail::true_t> : ordered_field_operators1<T, U> {}; template <class T, class B> struct ordered_field_operators<T, T, B, ::boost::detail::false_t> : ordered_field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidian_ring_operators : euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : euclidian_ring_operators1<T, U> {}; template <class T, class B> struct euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidian_ring_operators : ordered_euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidian_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidean_ring_operators : euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : euclidean_ring_operators1<T, U> {}; template <class T, class B> struct euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidean_ring_operators : ordered_euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidean_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::input_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class B> struct is_chained_base< ::boost::output_iteratable<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::forward_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::bidirectional_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::random_access_iteratable<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
# 891 "/usr/include/boost-1_42/boost/operators.hpp"
template <class T, class U>
struct operators2
    : totally_ordered2<T,U
    , integer_arithmetic2<T,U
    , bitwise2<T,U
      > > > {};


template <class T, class U = T>
struct operators : operators2<T, U> {};

template <class T> struct operators<T, T>



    : totally_ordered<T
    , integer_arithmetic<T
    , bitwise<T
    , unit_steppable<T
      > > > > {};




template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V const *,
          class R = V const &>
struct input_iterator_helper
  : input_iteratable<T, P
  , boost::iterator<std::input_iterator_tag, V, D, P, R
    > > {};

template<class T>
struct output_iterator_helper
  : output_iteratable<T
  , boost::iterator<std::output_iterator_tag, void, void, void, void
  > >
{
  T& operator*() { return static_cast<T&>(*this); }
  T& operator++() { return static_cast<T&>(*this); }
};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct forward_iterator_helper
  : forward_iteratable<T, P
  , boost::iterator<std::forward_iterator_tag, V, D, P, R
    > > {};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct bidirectional_iterator_helper
  : bidirectional_iteratable<T, P
  , boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
    > > {};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct random_access_iterator_helper
  : random_access_iteratable<T, P, D, R
  , boost::iterator<std::random_access_iterator_tag, V, D, P, R
    > >
{
  friend D requires_difference_operator(const T& x, const T& y) {
    return x - y;
  }
};

}
# 12 "/usr/include/boost-1_42/boost/python/type_id.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 2 3
# 14 "/usr/include/boost-1_42/boost/python/type_id.hpp" 2

# 1 "/usr/include/boost-1_42/boost/static_assert.hpp" 1
# 45 "/usr/include/boost-1_42/boost/static_assert.hpp"
namespace boost{


template <bool x> struct STATIC_ASSERTION_FAILURE;

template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };


template<int x> struct static_assert_test{};

}
# 16 "/usr/include/boost-1_42/boost/python/type_id.hpp" 2
# 28 "/usr/include/boost-1_42/boost/python/type_id.hpp"
namespace boost { namespace python {
# 44 "/usr/include/boost-1_42/boost/python/type_id.hpp"
bool cxxabi_cxa_demangle_is_broken();






struct type_info : private totally_ordered<type_info>
{
    inline type_info(std::type_info const& = typeid(void));

    inline bool operator<(type_info const& rhs) const;
    inline bool operator==(type_info const& rhs) const;

    char const* name() const;
    friend std::ostream& operator<<(
        std::ostream&, type_info const&);

 private:

    typedef char const* base_id_t;




    base_id_t m_base_type;
};







template <class T>
inline type_info type_id()
{
    return type_info(



        typeid(T)



        );
}
# 119 "/usr/include/boost-1_42/boost/python/type_id.hpp"
inline type_info::type_info(std::type_info const& id)
    : m_base_type(

        id.name()



        )
{
}

inline bool type_info::operator<(type_info const& rhs) const
{

    return std::strcmp(m_base_type, rhs.m_base_type) < 0;



}

inline bool type_info::operator==(type_info const& rhs) const
{

    return !std::strcmp(m_base_type, rhs.m_base_type);



}


namespace detail
{
  char const* gcc_demangle(char const*);
}


inline char const* type_info::name() const
{
    char const* raw_name
        = m_base_type



        ;


    return detail::gcc_demangle(raw_name);



}


 std::ostream& operator<<(std::ostream&, type_info const&);


template<>
inline type_info type_id<void>()
{
    return type_info (typeid (void *));
}

template<>
inline type_info type_id<const volatile void>()
{
    return type_info (typeid (void *));
}




}}
# 12 "/usr/include/boost-1_42/boost/python/instance_holder.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 13 "/usr/include/boost-1_42/boost/python/instance_holder.hpp" 2

namespace boost { namespace python {


struct instance_holder : private noncopyable
{
 public:
    instance_holder();
    virtual ~instance_holder();


    instance_holder* next() const;







    virtual void* holds(type_info, bool null_ptr_only) = 0;

    void install(PyObject* inst) throw();






    static void* allocate(PyObject*, std::size_t offset, std::size_t size);



    static void deallocate(PyObject*, void* storage) throw();
 private:
    instance_holder* m_next;
};







inline instance_holder* instance_holder::next() const
{
    return m_next;
}

}}
# 15 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/inheritance_query.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/object/inheritance_query.hpp"
namespace boost { namespace python { namespace objects {

 void* find_static_type(void* p, type_info src, type_info dst);
 void* find_dynamic_type(void* p, type_info src, type_info dst);

}}}
# 16 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/forward.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object/forward.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/value_arg.hpp" 1






# 1 "/usr/include/boost-1_42/boost/python/detail/copy_ctor_mutates_rhs.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/detail/is_auto_ptr.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/detail/is_auto_ptr.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/is_xxx.hpp" 1







# 1 "/usr/include/boost-1_42/boost/detail/is_xxx.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/detail/is_xxx.hpp" 2
# 10 "/usr/include/boost-1_42/boost/python/detail/is_auto_ptr.hpp" 2



namespace boost { namespace python { namespace detail {



template <class T> struct is_auto_ptr : mpl::false_ { }; template < class T0 > struct is_auto_ptr< std::auto_ptr< T0 > > : mpl::true_ { };
# 28 "/usr/include/boost-1_42/boost/python/detail/is_auto_ptr.hpp"
}}}
# 9 "/usr/include/boost-1_42/boost/python/detail/copy_ctor_mutates_rhs.hpp" 2


namespace boost { namespace python { namespace detail {

template <class T>
struct copy_ctor_mutates_rhs
    : is_auto_ptr<T>
{
};

}}}
# 8 "/usr/include/boost-1_42/boost/python/detail/value_arg.hpp" 2




namespace boost { namespace python { namespace detail {

template <class T>
struct value_arg
  : mpl::if_<
        copy_ctor_mutates_rhs<T>
      , T
      , typename add_reference<
            typename add_const<T>::type
        >::type
  >
{};

}}}
# 14 "/usr/include/boost-1_42/boost/python/object/forward.hpp" 2






# 1 "/usr/include/boost-1_42/boost/mpl/or.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/or.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/nested_type_wknd.hpp" 1
# 25 "/usr/include/boost-1_42/boost/mpl/aux_/nested_type_wknd.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T > struct nested_type_wknd
    : T::type
{
};
}}}
# 24 "/usr/include/boost-1_42/boost/mpl/or.hpp" 2
# 43 "/usr/include/boost-1_42/boost/mpl/or.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/or.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/or.hpp"
namespace boost { namespace mpl {

namespace aux {

template< bool C_, typename T1, typename T2, typename T3, typename T4 >
struct or_impl
    : true_
{
};

template< typename T1, typename T2, typename T3, typename T4 >
struct or_impl< false,T1,T2,T3,T4 >
    : or_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4
        , false_
        >
{
};

template<>
struct or_impl<
          false
        , false_, false_, false_, false_
        >
    : false_
{
};

}

template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = false_, typename T4 = false_, typename T5 = false_
    >
struct or_

    : aux::or_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4, T5
        >

{
   




};

template<> struct or_<



 na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : or_< T1 , T2 > { }; }; template< typename Tag > struct lambda< or_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef or_< na , na > result_; typedef or_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< or_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< or_< na , na > > : int_<-1> { }; }

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 44 "/usr/include/boost-1_42/boost/mpl/or.hpp" 2
# 21 "/usr/include/boost-1_42/boost/python/object/forward.hpp" 2


namespace boost { namespace python { namespace objects {




template <class T>
struct reference_to_value
{
    typedef typename add_reference<typename add_const<T>::type>::type reference;

    reference_to_value(reference x) : m_value(x) {}
    reference get() const { return m_value; }
 private:
    reference m_value;
};




template <class T>
struct forward
    : mpl::if_<
# 54 "/usr/include/boost-1_42/boost/python/object/forward.hpp"
          mpl::or_<python::detail::copy_ctor_mutates_rhs<T>, is_scalar<T> >

        , T
        , reference_to_value<T>
      >
{
};


template<typename T>
struct unforward
{
    typedef typename unwrap_reference<T>::type& type;
};

template<typename T>
struct unforward<reference_to_value<T> >
{
    typedef T type;
};

template <typename T>
struct unforward_cref
  : python::detail::value_arg<
        typename unwrap_reference<T>::type
    >
{
};

template<typename T>
struct unforward_cref<reference_to_value<T> >
  : add_reference<typename add_const<T>::type>
{
};
# 172 "/usr/include/boost-1_42/boost/python/object/forward.hpp"
template <class T>
typename reference_to_value<T>::reference
do_unforward(reference_to_value<T> const& x, int)
{
    return x.get();
}

template <class T>
typename reference_wrapper<T>::type&
do_unforward(reference_wrapper<T> const& x, int)
{
    return x.get();
}

template <class T>
T const& do_unforward(T const& x, ...)
{
    return x;
}

}}}
# 17 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/pointee.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/pointee.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/remove_pointer.hpp" 1
# 21 "/usr/include/boost-1_42/boost/type_traits/remove_pointer.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/remove_pointer.hpp" 2

namespace boost {



template< typename T > struct remove_pointer { typedef T type; };
template< typename T > struct remove_pointer<T*> { typedef T type; };
template< typename T > struct remove_pointer<T* const> { typedef T type; };
template< typename T > struct remove_pointer<T* volatile> { typedef T type; };
template< typename T > struct remove_pointer<T* const volatile> { typedef T type; };







}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 42 "/usr/include/boost-1_42/boost/type_traits/remove_pointer.hpp" 2
# 12 "/usr/include/boost-1_42/boost/python/pointee.hpp" 2

namespace boost { namespace python {

namespace detail
{
  template <bool is_ptr = true>
  struct pointee_impl
  {
      template <class T> struct apply : remove_pointer<T> {};
  };

  template <>
  struct pointee_impl<false>
  {
      template <class T> struct apply
      {
          typedef typename T::element_type type;
      };
  };
}

template <class T>
struct pointee
    : detail::pointee_impl<
        ::boost::is_pointer<T>::value
      >::template apply<T>
{
};

}}
# 19 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2


# 1 "/usr/include/boost-1_42/boost/python/detail/wrapper_base.hpp" 1







# 1 "/usr/include/boost-1_42/boost/type_traits/is_polymorphic.hpp" 1
# 17 "/usr/include/boost-1_42/boost/type_traits/is_polymorphic.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 18 "/usr/include/boost-1_42/boost/type_traits/is_polymorphic.hpp" 2


namespace boost{
# 106 "/usr/include/boost-1_42/boost/type_traits/is_polymorphic.hpp"
template< typename T > struct is_polymorphic : ::boost::integral_constant<bool,__is_polymorphic(T)> { };



}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 113 "/usr/include/boost-1_42/boost/type_traits/is_polymorphic.hpp" 2
# 9 "/usr/include/boost-1_42/boost/python/detail/wrapper_base.hpp" 2


namespace boost { namespace python {

class override;

namespace detail
{
  class wrapper_base;

  namespace wrapper_base_
  {
    inline PyObject* get_owner(wrapper_base const volatile& w);

    inline PyObject*
    owner_impl(void const volatile* , mpl::false_)
    {
        return 0;
    }

    template <class T>
    inline PyObject*
    owner_impl(T const volatile* x, mpl::true_);

    template <class T>
    inline PyObject*
    owner(T const volatile* x)
    {
        return wrapper_base_::owner_impl(x,is_polymorphic<T>());
    }
  }

  class wrapper_base
  {
      friend void initialize_wrapper(PyObject* self, wrapper_base* w);
      friend PyObject* wrapper_base_::get_owner(wrapper_base const volatile& w);
   protected:
      wrapper_base() : m_self(0) {}

      override get_override(
          char const* name, PyTypeObject* class_object) const;

   private:
      void detach();

   private:
      PyObject* m_self;
  };

  namespace wrapper_base_
  {
    template <class T>
    inline PyObject*
    owner_impl(T const volatile* x, mpl::true_)
    {
        if (wrapper_base const volatile* w = dynamic_cast<wrapper_base const volatile*>(x))
        {
            return wrapper_base_::get_owner(*w);
        }
        return 0;
    }

    inline PyObject* get_owner(wrapper_base const volatile& w)
    {
        return w.m_self;
    }
  }

  inline void initialize_wrapper(PyObject* self, wrapper_base* w)
  {
      w->m_self = self;
  }

  inline void initialize_wrapper(PyObject* , ...) {}



}

}}
# 22 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/force_instantiate.hpp" 1







namespace boost { namespace python { namespace detail {






template <class T>
inline void force_instantiate(T const&) {}
# 30 "/usr/include/boost-1_42/boost/python/detail/force_instantiate.hpp"
}}}
# 23 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2




# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/apply.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/apply_fwd.hpp" 1
# 31 "/usr/include/boost-1_42/boost/mpl/apply_fwd.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp"
namespace boost { namespace mpl {

template<
      typename F, typename T1 = na, typename T2 = na, typename T3 = na
    , typename T4 = na, typename T5 = na
    >
struct apply;

template<
      typename F
    >
struct apply0;

template<
      typename F, typename T1
    >
struct apply1;

template<
      typename F, typename T1, typename T2
    >
struct apply2;

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply3;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply4;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply5;

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 32 "/usr/include/boost-1_42/boost/mpl/apply_fwd.hpp" 2
# 23 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 24 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 1
# 24 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/arg.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/arg_fwd.hpp" 1
# 21 "/usr/include/boost-1_42/boost/mpl/arg_fwd.hpp"
namespace mpl_ {

template< int N > struct arg;

}
namespace boost { namespace mpl { using ::mpl_::arg; } }
# 24 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/aux_/na_assert.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/na_assert.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/assert.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/not.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/not.hpp"
namespace boost { namespace mpl {

namespace aux {

template< long C_ >
struct not_impl
    : bool_<!C_>
{
};

}


template<
      typename T = na
    >
struct not_
    : aux::not_impl<
          ::boost::mpl::aux::nested_type_wknd<T>::value
        >
{
   
};

template<> struct not_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_< T1 > { }; }; template< typename Tag > struct lambda< not_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef not_< na > result_; typedef not_< na > type; }; namespace aux { template< typename T1 > struct template_arity< not_< T1 > > : int_<1> { }; template<> struct template_arity< not_< na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost-1_42/boost/mpl/assert.hpp" 2
# 29 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/pp_counter.hpp" 1
# 30 "/usr/include/boost-1_42/boost/mpl/assert.hpp" 2





# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 36 "/usr/include/boost-1_42/boost/mpl/assert.hpp" 2
# 62 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
namespace mpl_ {

struct failed {};
# 75 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
template< bool C > struct assert { typedef void* type; };
template<> struct assert<false> { typedef assert type; };

template< bool C >
int assertion_failed( typename assert<C>::type );

template< bool C >
struct assertion
{
    static int failed( assert<false> );
};

template<>
struct assertion<true>
{
    static int failed( void* );
};

struct assert_
{

    template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {};

    static assert_ const arg;
    enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal };
};
# 123 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ );
boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ );
boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ );
boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ );
boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ );
boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ );

template< assert_::relations r, long x, long y > struct assert_relation {};






template< bool > struct assert_arg_pred_impl { typedef int type; };
template<> struct assert_arg_pred_impl<true> { typedef void* type; };

template< typename P > struct assert_arg_pred
{
    typedef typename P::type p_type;
    typedef typename assert_arg_pred_impl< p_type::value >::type type;
};

template< typename P > struct assert_arg_pred_not
{
    typedef typename P::type p_type;
    enum { p = !p_type::value };
    typedef typename assert_arg_pred_impl<p>::type type;
};

template< typename Pred >
failed ************ (Pred::************
      assert_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type )
    );

template< typename Pred >
failed ************ (boost::mpl::not_<Pred>::************
      assert_not_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type )
    );

template< typename Pred >
assert<false>
assert_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type );

template< typename Pred >
assert<false>
assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type );
# 212 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
}
# 24 "/usr/include/boost-1_42/boost/mpl/aux_/na_assert.hpp" 2
# 26 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arity_spec.hpp" 1
# 27 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arg_typedef.hpp" 1
# 28 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 2
# 37 "/usr/include/boost-1_42/boost/mpl/arg.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 1
# 13 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/arg.hpp"
namespace mpl_ {
template<> struct arg< -1 >
{
    static const int value = -1;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U1 type;
        enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<1>
{
    static const int value = 1;
    typedef arg<2> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U1 type;
        enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<2>
{
    static const int value = 2;
    typedef arg<3> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U2 type;
        enum { mpl_assertion_in_line_63 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<3>
{
    static const int value = 3;
    typedef arg<4> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U3 type;
        enum { mpl_assertion_in_line_81 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<4>
{
    static const int value = 4;
    typedef arg<5> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U4 type;
        enum { mpl_assertion_in_line_99 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<5>
{
    static const int value = 5;
    typedef arg<6> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U5 type;
        enum { mpl_assertion_in_line_117 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};



}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 38 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 2
# 25 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 2
# 43 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 1
# 13 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp"
namespace mpl_ {
typedef arg< -1 > _;
}
namespace boost { namespace mpl {

using ::mpl_::_;

namespace placeholders {
using mpl_::_;
}

}}



namespace mpl_ {
typedef arg<1> _1;

}
namespace boost { namespace mpl {

using ::mpl_::_1;

namespace placeholders {
using mpl_::_1;
}

}}
namespace mpl_ {
typedef arg<2> _2;

}
namespace boost { namespace mpl {

using ::mpl_::_2;

namespace placeholders {
using mpl_::_2;
}

}}
namespace mpl_ {
typedef arg<3> _3;

}
namespace boost { namespace mpl {

using ::mpl_::_3;

namespace placeholders {
using mpl_::_3;
}

}}
namespace mpl_ {
typedef arg<4> _4;

}
namespace boost { namespace mpl {

using ::mpl_::_4;

namespace placeholders {
using mpl_::_4;
}

}}
namespace mpl_ {
typedef arg<5> _5;

}
namespace boost { namespace mpl {

using ::mpl_::_5;

namespace placeholders {
using mpl_::_5;
}

}}
namespace mpl_ {
typedef arg<6> _6;

}
namespace boost { namespace mpl {

using ::mpl_::_6;

namespace placeholders {
using mpl_::_6;
}

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 44 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 2
# 25 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/lambda.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/lambda.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/bind.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/bind_fwd.hpp" 1
# 25 "/usr/include/boost-1_42/boost/mpl/bind_fwd.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/bind.hpp" 1
# 26 "/usr/include/boost-1_42/boost/mpl/bind_fwd.hpp" 2






# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp"
namespace boost { namespace mpl {

template<
      typename F, typename T1 = na, typename T2 = na, typename T3 = na
    , typename T4 = na, typename T5 = na
    >
struct bind;

template<
      typename F
    >
struct bind0;

template<
      typename F, typename T1
    >
struct bind1;

template<
      typename F, typename T1, typename T2
    >
struct bind2;

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind3;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind4;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind5;

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 33 "/usr/include/boost-1_42/boost/mpl/bind_fwd.hpp" 2
# 24 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 1
# 25 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/protect.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/protect.hpp"
namespace boost { namespace mpl {

template<
      typename T = na
    , int not_le_ = 0
    >
struct protect : T
{



    typedef protect type;

};
# 48 "/usr/include/boost-1_42/boost/mpl/protect.hpp"
template<> struct protect< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : protect< T1 > { }; };

namespace aux { template< typename T1 > struct template_arity< protect< T1 > > : int_<1> { }; template<> struct template_arity< protect< na > > : int_<-1> { }; }


}}
# 27 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 28 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 2
# 50 "/usr/include/boost-1_42/boost/mpl/bind.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 1
# 13 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/bind.hpp"
namespace boost { namespace mpl {

namespace aux {

template<
      typename T, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg
{
    typedef T type;
};

template<
      typename T
    , typename Arg
    >
struct replace_unnamed_arg
{
    typedef Arg next;
    typedef T type;
};

template<
      typename Arg
    >
struct replace_unnamed_arg< arg< -1 >, Arg >
{
    typedef typename Arg::next next;
    typedef Arg type;
};

template<
      int N, typename U1, typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
{
    typedef typename apply_wrap5<mpl::arg<N>, U1, U2, U3, U4, U5>::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 >
{
    typedef bind< F,T1,T2,T3,T4,T5 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}

template<
      typename F
    >
struct bind0
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

     public:
        typedef typename apply_wrap0<
              f_
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg<
      bind0<F>, U1, U2, U3, U4, U5
    >
{
    typedef bind0<F> f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 > struct template_arity< bind0< T1> > : int_<1> { }; }

template<
      typename F
    >
struct bind< F,na,na,na,na,na >
    : bind0<F>
{
};

template<
      typename F, typename T1
    >
struct bind1
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

     public:
        typedef typename apply_wrap1<
              f_
            , typename t1::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename U1, typename U2, typename U3
    , typename U4, typename U5
    >
struct resolve_bind_arg<
      bind1< F,T1 >, U1, U2, U3, U4, U5
    >
{
    typedef bind1< F,T1 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 > struct template_arity< bind1< T1 , T2> > : int_<2> { }; }

template<
      typename F, typename T1
    >
struct bind< F,T1,na,na,na,na >
    : bind1< F,T1 >
{
};

template<
      typename F, typename T1, typename T2
    >
struct bind2
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

     public:
        typedef typename apply_wrap2<
              f_
            , typename t1::type, typename t2::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename U1, typename U2
    , typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind2< F,T1,T2 >, U1, U2, U3, U4, U5
    >
{
    typedef bind2< F,T1,T2 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< bind2< T1 , T2 , T3> > : int_<3> { }; }

template<
      typename F, typename T1, typename T2
    >
struct bind< F,T1,T2,na,na,na >
    : bind2< F,T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind3
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

     public:
        typedef typename apply_wrap3<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename U1
    , typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
    >
{
    typedef bind3< F,T1,T2,T3 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< bind3< T1 , T2 , T3 , T4> > : int_<4> { }; }

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind< F,T1,T2,T3,na,na >
    : bind3< F,T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind4
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef aux::replace_unnamed_arg< T4,n4 > r4;
        typedef typename r4::type a4;
        typedef typename r4::next n5;
        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;

     public:
        typedef typename apply_wrap4<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            , typename t4::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename U1, typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
    >
{
    typedef bind4< F,T1,T2,T3,T4 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bind4< T1 , T2 , T3 , T4 , T5> > : int_<5> { }; }

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind< F,T1,T2,T3,T4,na >
    : bind4< F,T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind5
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef aux::replace_unnamed_arg< T4,n4 > r4;
        typedef typename r4::type a4;
        typedef typename r4::next n5;
        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;

        typedef aux::replace_unnamed_arg< T5,n5 > r5;
        typedef typename r5::type a5;
        typedef typename r5::next n6;
        typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5;

     public:
        typedef typename apply_wrap5<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            , typename t4::type, typename t5::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg<
      bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
    >
{
    typedef bind5< F,T1,T2,T3,T4,T5 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< bind5< T1 , T2 , T3 , T4 , T5 , T6> > : int_<6> { }; }



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind
    : bind5< F,T1,T2,T3,T4,T5 >
{
};


template< template< typename T1, typename T2, typename T3 > class F, typename Tag >
struct quote3;

template< typename T1, typename T2, typename T3 > struct if_;

template<
      typename Tag, typename T1, typename T2, typename T3
    >
struct bind3<
      quote3< if_,Tag >
    , T1, T2, T3
    >
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef mpl::arg<1> n1;
        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef typename if_<
              typename t1::type
            , t2, t3
            >::type f_;

     public:
        typedef typename f_::type type;
    };
};

template<
      template< typename T1, typename T2, typename T3 > class F, typename Tag
    >
struct quote3;

template< typename T1, typename T2, typename T3 > struct eval_if;

template<
      typename Tag, typename T1, typename T2, typename T3
    >
struct bind3<
      quote3< eval_if,Tag >
    , T1, T2, T3
    >
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef mpl::arg<1> n1;
        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef typename eval_if<
              typename t1::type
            , t2, t3
            >::type f_;

     public:
        typedef typename f_::type type;
    };
};

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 51 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 2
# 19 "/usr/include/boost-1_42/boost/mpl/lambda.hpp" 2



# 1 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/bind_fwd.hpp" 1
# 24 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/quote.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/quote.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/has_type.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/has_type.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 24 "/usr/include/boost-1_42/boost/mpl/quote.hpp" 2


# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/bcc.hpp" 1
# 27 "/usr/include/boost-1_42/boost/mpl/quote.hpp" 2
# 45 "/usr/include/boost-1_42/boost/mpl/quote.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/quote.hpp"
namespace boost { namespace mpl {

template< typename T, bool has_type_ >
struct quote_impl
{
    typedef typename T::type type;
};

template< typename T >
struct quote_impl< T,false >
{
    typedef T type;
};

template<
      template< typename P1 > class F
    , typename Tag = void_
    >
struct quote1
{
    template< typename U1 > struct apply

        : quote_impl<
              F<U1>
            , aux::has_type< F<U1> >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2 > class F
    , typename Tag = void_
    >
struct quote2
{
    template< typename U1, typename U2 > struct apply

        : quote_impl<
              F< U1,U2 >
            , aux::has_type< F< U1,U2 > >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename Tag = void_
    >
struct quote3
{
    template< typename U1, typename U2, typename U3 > struct apply

        : quote_impl<
              F< U1,U2,U3 >
            , aux::has_type< F< U1,U2,U3 > >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename Tag = void_
    >
struct quote4
{
    template<
          typename U1, typename U2, typename U3, typename U4
        >
    struct apply

        : quote_impl<
              F< U1,U2,U3,U4 >
            , aux::has_type< F< U1,U2,U3,U4 > >::value
            >

    {
    };
};

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename Tag = void_
    >
struct quote5
{
    template<
          typename U1, typename U2, typename U3, typename U4
        , typename U5
        >
    struct apply

        : quote_impl<
              F< U1,U2,U3,U4,U5 >
            , aux::has_type< F< U1,U2,U3,U4,U5 > >::value
            >

    {
    };
};

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 46 "/usr/include/boost-1_42/boost/mpl/quote.hpp" 2
# 26 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 1
# 27 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 2


# 1 "/usr/include/boost-1_42/boost/mpl/aux_/template_arity.hpp" 1
# 43 "/usr/include/boost-1_42/boost/mpl/aux_/template_arity.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp"
namespace boost { namespace mpl { namespace aux {

template< int N > struct arity_tag
{
    typedef char (&type)[N + 1];
};

template<
      int C1, int C2, int C3, int C4, int C5, int C6
    >
struct max_arity
{
    static const int value = ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) )


         ;
};

arity_tag<0>::type arity_helper(...);

template<
      template< typename P1 > class F
    , typename T1
    >
typename arity_tag<1>::type
arity_helper(type_wrapper< F<T1> >, arity_tag<1>);

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    >
typename arity_tag<2>::type
arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>);

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    >
typename arity_tag<3>::type
arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>);

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    >
typename arity_tag<4>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>);

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    >
typename arity_tag<5>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>);

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5, typename P6
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    , typename T6
    >
typename arity_tag<6>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>);
template< typename F, int N >
struct template_arity_impl
{
    static const int value = sizeof(arity_helper(type_wrapper<F>(), arity_tag<N>())) - 1

         ;
};

template< typename F >
struct template_arity
{
    static const int value = ( max_arity< template_arity_impl< F,1 >::value, template_arity_impl< F,2 >::value, template_arity_impl< F,3 >::value, template_arity_impl< F,4 >::value, template_arity_impl< F,5 >::value, template_arity_impl< F,6 >::value >::value )


          ;

    typedef mpl::int_<value> type;
};

}}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 44 "/usr/include/boost-1_42/boost/mpl/aux_/template_arity.hpp" 2
# 30 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 2
# 44 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp"
namespace boost { namespace mpl {

namespace aux {

template<
      bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false
    , bool C5 = false
    >
struct lambda_or
    : true_
{
};

template<>
struct lambda_or< false,false,false,false,false >
    : false_
{
};

}

template<
      typename T
    , typename Tag
    , typename Arity
    >
struct lambda
{
    typedef false_ is_le;
    typedef T result_;
    typedef T type;
};

template<
      typename T
    >
struct is_lambda_expression
    : lambda<T>::is_le
{
};

template< int N, typename Tag >
struct lambda< arg<N>,Tag, int_< -1 > >
{
    typedef true_ is_le;
    typedef mpl::arg<N> result_;
    typedef mpl::protect<result_> type;
};

template<
      typename F
    , typename Tag
    >
struct lambda<
          bind0<F>
        , Tag
        , int_<1>
        >
{
    typedef false_ is_le;
    typedef bind0<
          F
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1 > class F
    , typename L1
    >
struct le_result1
{
    typedef F<
          typename L1::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1 > class F
    , typename L1
    >
struct le_result1< true_,Tag,F,L1 >
{
    typedef bind1<
          quote1< F,Tag >
        , typename L1::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1 > class F
    , typename T1
    , typename Tag
    >
struct lambda<
          F<T1>
        , Tag
        , int_<1>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef typename l1::is_le is_le1;
    typedef typename aux::lambda_or<
          is_le1::value
        >::type is_le;

    typedef aux::le_result1<
          is_le, Tag, F, l1
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1
    , typename Tag
    >
struct lambda<
          bind1< F,T1 >
        , Tag
        , int_<2>
        >
{
    typedef false_ is_le;
    typedef bind1<
          F
        , T1
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2
{
    typedef F<
          typename L1::type, typename L2::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2< true_,Tag,F,L1,L2 >
{
    typedef bind2<
          quote2< F,Tag >
        , typename L1::result_, typename L2::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    , typename Tag
    >
struct lambda<
          F< T1,T2 >
        , Tag
        , int_<2>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value
        >::type is_le;

    typedef aux::le_result2<
          is_le, Tag, F, l1, l2
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2
    , typename Tag
    >
struct lambda<
          bind2< F,T1,T2 >
        , Tag
        , int_<3>
        >
{
    typedef false_ is_le;
    typedef bind2<
          F
        , T1, T2
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3< true_,Tag,F,L1,L2,L3 >
{
    typedef bind3<
          quote3< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3 >
        , Tag
        , int_<3>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value
        >::type is_le;

    typedef aux::le_result3<
          is_le, Tag, F, l1, l2, l3
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3
    , typename Tag
    >
struct lambda<
          bind3< F,T1,T2,T3 >
        , Tag
        , int_<4>
        >
{
    typedef false_ is_le;
    typedef bind3<
          F
        , T1, T2, T3
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        , typename L4::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
{
    typedef bind4<
          quote4< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        , typename L4::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3,T4 >
        , Tag
        , int_<4>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;
    typedef lambda< T4,Tag > l4;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;
    typedef typename l4::is_le is_le4;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value, is_le4::value
        >::type is_le;

    typedef aux::le_result4<
          is_le, Tag, F, l1, l2, l3, l4
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename Tag
    >
struct lambda<
          bind4< F,T1,T2,T3,T4 >
        , Tag
        , int_<5>
        >
{
    typedef false_ is_le;
    typedef bind4<
          F
        , T1, T2, T3, T4
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        , typename L4::type, typename L5::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
{
    typedef bind5<
          quote5< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        , typename L4::result_, typename L5::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3,T4,T5 >
        , Tag
        , int_<5>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;
    typedef lambda< T4,Tag > l4;
    typedef lambda< T5,Tag > l5;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;
    typedef typename l4::is_le is_le4;
    typedef typename l5::is_le is_le5;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value, is_le4::value
        , is_le5::value
        >::type is_le;

    typedef aux::le_result5<
          is_le, Tag, F, l1, l2, l3, l4, l5
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    , typename Tag
    >
struct lambda<
          bind5< F,T1,T2,T3,T4,T5 >
        , Tag
        , int_<6>
        >
{
    typedef false_ is_le;
    typedef bind5<
          F
        , T1, T2, T3, T4, T5
        > result_;

    typedef result_ type;
};


template< typename T, typename Tag >
struct lambda< mpl::protect<T>,Tag, int_<1> >
{
    typedef false_ is_le;
    typedef mpl::protect<T> result_;
    typedef result_ type;
};



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    , typename Tag
    >
struct lambda<
          bind< F,T1,T2,T3,T4,T5 >
        , Tag
        , int_<6>
        >
{
    typedef false_ is_le;
    typedef bind< F,T1,T2,T3,T4,T5 > result_;
    typedef result_ type;
};

template<
      typename F
    , typename Tag1
    , typename Tag2
    , typename Arity
    >
struct lambda<
          lambda< F,Tag1,Arity >
        , Tag2
        , int_<3>
        >
{
    typedef lambda< F,Tag2 > l1;
    typedef lambda< Tag1,Tag2 > l2;
    typedef typename l1::is_le is_le;
    typedef bind1< quote1<aux::template_arity>, typename l1::result_ > arity_;
    typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3;
    typedef aux::le_result3<is_le, Tag2, mpl::lambda, l1, l2, l3> le_result_;
    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<> struct lambda< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lambda< T1 , T2 > { }; }; template< typename Tag > struct lambda< lambda< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lambda< na , na > result_; typedef lambda< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< lambda< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< lambda< na , na > > : int_<-1> { }; }

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 45 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 2
# 23 "/usr/include/boost-1_42/boost/mpl/lambda.hpp" 2
# 26 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 2
# 36 "/usr/include/boost-1_42/boost/mpl/apply.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply.hpp"
namespace boost { namespace mpl {

template<
      typename F
    >
struct apply0

    : apply_wrap0<
          typename lambda<F>::type

        >
{
   




};

template<
      typename F
    >
struct apply< F,na,na,na,na,na >
    : apply0<F>
{
};

template<
      typename F, typename T1
    >
struct apply1

    : apply_wrap1<
          typename lambda<F>::type
        , T1
        >
{
   




};

template<
      typename F, typename T1
    >
struct apply< F,T1,na,na,na,na >
    : apply1< F,T1 >
{
};

template<
      typename F, typename T1, typename T2
    >
struct apply2

    : apply_wrap2<
          typename lambda<F>::type
        , T1, T2
        >
{
   




};

template<
      typename F, typename T1, typename T2
    >
struct apply< F,T1,T2,na,na,na >
    : apply2< F,T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply3

    : apply_wrap3<
          typename lambda<F>::type
        , T1, T2, T3
        >
{
   




};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply< F,T1,T2,T3,na,na >
    : apply3< F,T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply4

    : apply_wrap4<
          typename lambda<F>::type
        , T1, T2, T3, T4
        >
{
   




};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply< F,T1,T2,T3,T4,na >
    : apply4< F,T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply5

    : apply_wrap5<
          typename lambda<F>::type
        , T1, T2, T3, T4, T5
        >
{
   




};



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply
    : apply5< F,T1,T2,T3,T4,T5 >
{
};

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 37 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 2
# 28 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2




# 1 "/usr/include/boost-1_42/boost/preprocessor/debug/line.hpp" 1
# 33 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2





namespace boost { namespace python {

template <class T> class wrapper;

}}


namespace boost { namespace python { namespace objects {







template <class Pointer, class Value>
struct pointer_holder : instance_holder
{
    typedef Value value_type;

    pointer_holder(Pointer);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"







    pointer_holder(PyObject* self )
        : m_p(new Value(
               
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 >

    pointer_holder(PyObject* self , A0 a0)
        : m_p(new Value(
                objects::do_unforward(a0,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 >

    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13 , A14 a14)
        : m_p(new Value(
                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0) , objects::do_unforward(a14,0)
            ))
    {
        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
    }
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 64 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2

 private:

 private:
    void* holds(type_info, bool null_ptr_only);

    template <class T>
    inline void* holds_wrapped(type_info dst_t, wrapper<T>*,T* p)
    {
        return python::type_id<T>() == dst_t ? p : 0;
    }

    inline void* holds_wrapped(type_info, ...)
    {
        return 0;
    }

 private:
    Pointer m_p;
};

template <class Pointer, class Value>
struct pointer_holder_back_reference : instance_holder
{
 private:
    typedef typename python::pointee<Pointer>::type held_type;
 public:
    typedef Value value_type;



    pointer_holder_back_reference(Pointer);



# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"







    pointer_holder_back_reference(
        PyObject* p )
        : m_p(new held_type(
                    p
            ))
    {}
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0)
            ))
    {}
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0)
            ))
    {}
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0)
            ))
    {}
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0)
            ))
    {}
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0)
            ))
    {}
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0)
            ))
    {}
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0)
            ))
    {}
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0)
            ))
    {}
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0)
            ))
    {}
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0)
            ))
    {}
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0)
            ))
    {}
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0)
            ))
    {}
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0)
            ))
    {}
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0)
            ))
    {}
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 >

    pointer_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13 , A14 a14)
        : m_p(new held_type(
                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0) , objects::do_unforward(a14,0)
            ))
    {}
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 100 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2

 private:
    void* holds(type_info, bool null_ptr_only);

 private:
    Pointer m_p;
};



template <class Pointer, class Value>
inline pointer_holder<Pointer,Value>::pointer_holder(Pointer p)
    : m_p(p)
{
}

template <class Pointer, class Value>
inline pointer_holder_back_reference<Pointer,Value>::pointer_holder_back_reference(Pointer p)
    : m_p(p)
{
}

template <class Pointer, class Value>
void* pointer_holder<Pointer, Value>::holds(type_info dst_t, bool null_ptr_only)
{
    if (dst_t == python::type_id<Pointer>()
        && !(null_ptr_only && get_pointer(this->m_p))
    )
        return &this->m_p;

    Value* p



        = get_pointer(this->m_p)

        ;

    if (p == 0)
        return 0;

    if (void* wrapped = holds_wrapped(dst_t, p, p))
        return wrapped;

    type_info src_t = python::type_id<Value>();
    return src_t == dst_t ? p : find_dynamic_type(p, src_t, dst_t);
}

template <class Pointer, class Value>
void* pointer_holder_back_reference<Pointer, Value>::holds(type_info dst_t, bool null_ptr_only)
{
    if (dst_t == python::type_id<Pointer>()
        && !(null_ptr_only && get_pointer(this->m_p))
    )
        return &this->m_p;

    if (!get_pointer(this->m_p))
        return 0;

    Value* p = get_pointer(m_p);

    if (dst_t == python::type_id<held_type>())
        return p;

    type_info src_t = python::type_id<Value>();
    return src_t == dst_t ? p : find_dynamic_type(p, src_t, dst_t);
}

}}}
# 11 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/make_ptr_instance.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/instance.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/object/instance.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/alignment_traits.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/alignment_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 1
# 12 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/list/for_each_i.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/list/for_each_i.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/for.hpp" 1
# 19 "/usr/include/boost-1_42/boost/preprocessor/repetition/for.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/repetition/for.hpp" 2
# 42 "/usr/include/boost-1_42/boost/preprocessor/repetition/for.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/detail/for.hpp" 1
# 43 "/usr/include/boost-1_42/boost/preprocessor/repetition/for.hpp" 2
# 21 "/usr/include/boost-1_42/boost/preprocessor/list/for_each_i.hpp" 2
# 13 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/to_list.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/list/transform.hpp" 1
# 16 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/list/append.hpp" 1
# 17 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2






# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 24 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 26 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2






namespace boost {



namespace detail {

class alignment_dummy;
typedef void (*function_ptr)();
typedef int (alignment_dummy::*member_ptr);
typedef int (alignment_dummy::*member_function_ptr)();
# 101 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
template <bool found, std::size_t target, class TestType>
struct lower_alignment_helper
{
    typedef char type;
    enum { value = true };
};

template <std::size_t target, class TestType>
struct lower_alignment_helper<false,target,TestType>
{
    enum { value = (alignment_of<TestType>::value == target) };
    typedef typename mpl::if_c<value, TestType, char>::type type;
};
# 127 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
template <typename T>
struct has_one_T
{
  T data;
};

template <std::size_t target>
union lower_alignment
{
    enum { found0 = false };

   



 typename lower_alignment_helper< found0,target,char >::type t0; enum { found1 = lower_alignment_helper<found0,target,char >::value }; typename lower_alignment_helper< found1,target,short >::type t1; enum { found2 = lower_alignment_helper<found1,target,short >::value }; typename lower_alignment_helper< found2,target,int >::type t2; enum { found3 = lower_alignment_helper<found2,target,int >::value }; typename lower_alignment_helper< found3,target,long >::type t3; enum { found4 = lower_alignment_helper<found3,target,long >::value }; typename lower_alignment_helper< found4,target,::boost::long_long_type >::type t4; enum { found5 = lower_alignment_helper<found4,target,::boost::long_long_type >::value }; typename lower_alignment_helper< found5,target,float >::type t5; enum { found6 = lower_alignment_helper<found5,target,float >::value }; typename lower_alignment_helper< found6,target,double >::type t6; enum { found7 = lower_alignment_helper<found6,target,double >::value }; typename lower_alignment_helper< found7,target,long double >::type t7; enum { found8 = lower_alignment_helper<found7,target,long double >::value }; typename lower_alignment_helper< found8,target,void* >::type t8; enum { found9 = lower_alignment_helper<found8,target,void* >::value }; typename lower_alignment_helper< found9,target,function_ptr >::type t9; enum { found10 = lower_alignment_helper<found9,target,function_ptr >::value }; typename lower_alignment_helper< found10,target,member_ptr >::type t10; enum { found11 = lower_alignment_helper<found10,target,member_ptr >::value }; typename lower_alignment_helper< found11,target,member_function_ptr >::type t11; enum { found12 = lower_alignment_helper<found11,target,member_function_ptr >::value }; typename lower_alignment_helper< found12,target,boost::detail::has_one_T< char > >::type t12; enum { found13 = lower_alignment_helper<found12,target,boost::detail::has_one_T< char > >::value }; typename lower_alignment_helper< found13,target,boost::detail::has_one_T< short > >::type t13; enum { found14 = lower_alignment_helper<found13,target,boost::detail::has_one_T< short > >::value }; typename lower_alignment_helper< found14,target,boost::detail::has_one_T< int > >::type t14; enum { found15 = lower_alignment_helper<found14,target,boost::detail::has_one_T< int > >::value }; typename lower_alignment_helper< found15,target,boost::detail::has_one_T< long > >::type t15; enum { found16 = lower_alignment_helper<found15,target,boost::detail::has_one_T< long > >::value }; typename lower_alignment_helper< found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::type t16; enum { found17 = lower_alignment_helper<found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::value }; typename lower_alignment_helper< found17,target,boost::detail::has_one_T< float > >::type t17; enum { found18 = lower_alignment_helper<found17,target,boost::detail::has_one_T< float > >::value }; typename lower_alignment_helper< found18,target,boost::detail::has_one_T< double > >::type t18; enum { found19 = lower_alignment_helper<found18,target,boost::detail::has_one_T< double > >::value }; typename lower_alignment_helper< found19,target,boost::detail::has_one_T< long double > >::type t19; enum { found20 = lower_alignment_helper<found19,target,boost::detail::has_one_T< long double > >::value }; typename lower_alignment_helper< found20,target,boost::detail::has_one_T< void* > >::type t20; enum { found21 = lower_alignment_helper<found20,target,boost::detail::has_one_T< void* > >::value }; typename lower_alignment_helper< found21,target,boost::detail::has_one_T< function_ptr > >::type t21; enum { found22 = lower_alignment_helper<found21,target,boost::detail::has_one_T< function_ptr > >::value }; typename lower_alignment_helper< found22,target,boost::detail::has_one_T< member_ptr > >::type t22; enum { found23 = lower_alignment_helper<found22,target,boost::detail::has_one_T< member_ptr > >::value }; typename lower_alignment_helper< found23,target,boost::detail::has_one_T< member_function_ptr > >::type t23; enum { found24 = lower_alignment_helper<found23,target,boost::detail::has_one_T< member_function_ptr > >::value };
};

union max_align
{
   



 char t0; short t1; int t2; long t3; ::boost::long_long_type t4; float t5; double t6; long double t7; void* t8; function_ptr t9; member_ptr t10; member_function_ptr t11; boost::detail::has_one_T< char > t12; boost::detail::has_one_T< short > t13; boost::detail::has_one_T< int > t14; boost::detail::has_one_T< long > t15; boost::detail::has_one_T< ::boost::long_long_type > t16; boost::detail::has_one_T< float > t17; boost::detail::has_one_T< double > t18; boost::detail::has_one_T< long double > t19; boost::detail::has_one_T< void* > t20; boost::detail::has_one_T< function_ptr > t21; boost::detail::has_one_T< member_ptr > t22; boost::detail::has_one_T< member_function_ptr > t23;
};
# 161 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
template<std::size_t TAlign, std::size_t Align>
struct is_aligned
{
    static const bool value = (TAlign >= Align) & (TAlign % Align == 0)

         ;
};
# 180 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
}


template<std::size_t Align>
struct is_pod< ::boost::detail::lower_alignment<Align> >
{
        static const std::size_t value = true;
};




namespace detail{

template <std::size_t Align>
class type_with_alignment_imp
{
    typedef ::boost::detail::lower_alignment<Align> t1;
    typedef typename mpl::if_c<
          ::boost::detail::is_aligned< ::boost::alignment_of<t1>::value,Align >::value
        , t1
        , ::boost::detail::max_align
        >::type align_t;

    static const std::size_t found = alignment_of<align_t>::value;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((found >= Align) == 0 ? false : true) >)> boost_static_assert_typedef_206;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((found % Align == 0) == 0 ? false : true) >)> boost_static_assert_typedef_207;

 public:
    typedef align_t type;
};

}

template <std::size_t Align>
class type_with_alignment
  : public ::boost::detail::type_with_alignment_imp<Align>
{
};


namespace align {
struct __attribute__((__aligned__(2))) a2 {};
struct __attribute__((__aligned__(4))) a4 {};
struct __attribute__((__aligned__(8))) a8 {};
struct __attribute__((__aligned__(16))) a16 {};
struct __attribute__((__aligned__(32))) a32 {};
}

template<> class type_with_alignment<1> { public: typedef char type; };
template<> class type_with_alignment<2> { public: typedef align::a2 type; };
template<> class type_with_alignment<4> { public: typedef align::a4 type; };
template<> class type_with_alignment<8> { public: typedef align::a8 type; };
template<> class type_with_alignment<16> { public: typedef align::a16 type; };
template<> class type_with_alignment<32> { public: typedef align::a32 type; };

namespace detail {
template<> struct is_pod_impl< ::boost::align::a2 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a4 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a8 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a16 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a32 > { static const bool value = (true); };
}
# 383 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
}





# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 390 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2
# 14 "/usr/include/boost-1_42/boost/type_traits/alignment_traits.hpp" 2
# 10 "/usr/include/boost-1_42/boost/python/object/instance.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 11 "/usr/include/boost-1_42/boost/python/object/instance.hpp" 2

namespace boost { namespace python
{
  struct instance_holder;
}}

namespace boost { namespace python { namespace objects {


template <class Data = char>
struct instance
{
    Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
    PyObject* dict;
    PyObject* weakrefs;
    instance_holder* objects;

    typedef typename type_with_alignment<
        ::boost::alignment_of<Data>::value
    >::type align_t;

    union
    {
        align_t align;
        char bytes[sizeof(Data)];
    } storage;
};

template <class Data>
struct additional_instance_size
{
    typedef instance<Data> instance_data;
    typedef instance<char> instance_char;
    static const std::size_t value = sizeof(instance_data) - __builtin_offsetof (instance_char, storage)

                                                                          ;
};

}}}
# 10 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/converter/registered.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/converter/registry.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/converter/to_python_function_type.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/converter/to_python_function_type.hpp"
namespace boost { namespace python { namespace converter {




typedef PyObject* (*to_python_function_t)(void const*);

}}}
# 9 "/usr/include/boost-1_42/boost/python/converter/registry.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/converter/constructor_function.hpp" 1







namespace boost { namespace python { namespace converter {



struct rvalue_from_python_stage1_data;
typedef void (*constructor_function)(PyObject* source, rvalue_from_python_stage1_data*);

}}}
# 9 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/referent_storage.hpp" 1







# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 9 "/usr/include/boost-1_42/boost/python/detail/referent_storage.hpp" 2

namespace boost { namespace python { namespace detail {

struct alignment_dummy;
typedef void (*function_ptr)();
typedef int (alignment_dummy::*member_ptr);
typedef int (alignment_dummy::*member_function_ptr)();






template <std::size_t size>
union aligned_storage
{
    typename mpl::if_c< sizeof(char) <= size, char, char>::type t0;
    typename mpl::if_c< sizeof(short) <= size, short, char>::type t1;
    typename mpl::if_c< sizeof(int) <= size, int, char>::type t2;
    typename mpl::if_c< sizeof(long) <= size, long, char>::type t3;
    typename mpl::if_c< sizeof(float) <= size, float, char>::type t4;
    typename mpl::if_c< sizeof(double) <= size, double, char>::type t5;
    typename mpl::if_c< sizeof(long double) <= size, long double, char>::type t6;
    typename mpl::if_c< sizeof(void*) <= size, void*, char>::type t7;
    typename mpl::if_c< sizeof(function_ptr) <= size, function_ptr, char>::type t8;
    typename mpl::if_c< sizeof(member_ptr) <= size, member_ptr, char>::type t9;
    typename mpl::if_c< sizeof(member_function_ptr) <= size, member_function_ptr, char>::type t10;
    char bytes[size];
};





  template <class T> struct referent_size;



  template <class T>
  struct referent_size<T&>
  {
      static const std::size_t value = sizeof(T)
                                         ;
  };
# 66 "/usr/include/boost-1_42/boost/python/detail/referent_storage.hpp"
template <class T>
struct referent_storage
{
    typedef aligned_storage<
        ::boost::python::detail::referent_size<T>::value
    > type;
};

}}}
# 10 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/destroy.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/detail/destroy.hpp"
namespace boost { namespace python { namespace detail {

template <
    bool array



    > struct value_destroyer;

template <>
struct value_destroyer<
    false



    >
{
    template <class T>
    static void execute(T const volatile* p)
    {
        p->T::~T();
    }
};

template <>
struct value_destroyer<
    true



    >
{
    template <class A, class T>
    static void execute(A*, T const volatile* const first)
    {
        for (T const volatile* p = first; p != first + sizeof(A)/sizeof(T); ++p)
        {
            value_destroyer<
                boost::is_array<T>::value



            >::execute(p);
        }
    }

    template <class T>
    static void execute(T const volatile* p)
    {
        execute(p, *p);
    }
};
# 85 "/usr/include/boost-1_42/boost/python/detail/destroy.hpp"
template <class T>
inline void destroy_referent_impl(void* p, T& (*)())
{


    value_destroyer<
         (boost::is_array<T>::value)



    >::execute((const volatile T*)p);
}

template <class T>
inline void destroy_referent(void* p, T(*)() = 0)
{
    destroy_referent_impl(p, (T(*)())0);
}

}}}
# 11 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp" 2



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 15 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp" 2
# 39 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp"
namespace boost { namespace python { namespace converter {
# 62 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp"
struct rvalue_from_python_stage1_data
{
    void* convertible;
    constructor_function construct;
};







template <class T>
struct rvalue_from_python_storage
{
    rvalue_from_python_stage1_data stage1;


    typename python::detail::referent_storage<
        typename add_reference<T>::type
    >::type storage;
};







template <class T>
struct rvalue_from_python_data : rvalue_from_python_storage<T>
{





    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((__builtin_offsetof (rvalue_from_python_storage<T>, stage1) == 0) == 0 ? false : true) >)> boost_static_assert_typedef_99;



    rvalue_from_python_data(rvalue_from_python_stage1_data const&);




    rvalue_from_python_data(void* convertible);


    ~rvalue_from_python_data();
 private:
    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
};




template <class T>
inline rvalue_from_python_data<T>::rvalue_from_python_data(rvalue_from_python_stage1_data const& _stage1)
{
    this->stage1 = _stage1;
}

template <class T>
inline rvalue_from_python_data<T>::rvalue_from_python_data(void* convertible)
{
    this->stage1.convertible = convertible;
}

template <class T>
inline rvalue_from_python_data<T>::~rvalue_from_python_data()
{
    if (this->stage1.convertible == this->storage.bytes)
        python::detail::destroy_referent<ref_type>(this->storage.bytes);
}

}}}
# 10 "/usr/include/boost-1_42/boost/python/converter/registry.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/converter/convertible_function.hpp" 1







namespace boost { namespace python { namespace converter {

typedef void* (*convertible_function)(PyObject*);

}}}
# 12 "/usr/include/boost-1_42/boost/python/converter/registry.hpp" 2

namespace boost { namespace python { namespace converter {

struct registration;


namespace registry
{

  registration const& lookup(type_info);



  registration const& lookup_shared_ptr(type_info);


  registration const* query(type_info);

  void insert(to_python_function_t, type_info, PyTypeObject const* (*to_python_target_type)() = 0);


  void insert(void* (*convert)(PyObject*), type_info, PyTypeObject const* (*expected_pytype)() = 0);


  void insert(
      convertible_function
      , constructor_function
      , type_info
      , PyTypeObject const* (*expected_pytype)() = 0
      );



  void push_back(
      convertible_function
      , constructor_function
      , type_info
      , PyTypeObject const* (*expected_pytype)() = 0
      );
}

}}}
# 9 "/usr/include/boost-1_42/boost/python/converter/registered.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/converter/registrations.hpp" 1
# 18 "/usr/include/boost-1_42/boost/python/converter/registrations.hpp"
namespace boost { namespace python { namespace converter {

struct lvalue_from_python_chain
{
    convertible_function convert;
    lvalue_from_python_chain* next;
};

struct rvalue_from_python_chain
{
    convertible_function convertible;
    constructor_function construct;
    PyTypeObject const* (*expected_pytype)();
    rvalue_from_python_chain* next;
};

struct registration
{
 public:
    explicit registration(type_info target, bool is_shared_ptr = false);
   ~registration();


    PyObject* to_python(void const volatile*) const;



    PyTypeObject* get_class_object() const;



    PyTypeObject const* expected_from_python_type() const;
    PyTypeObject const* to_python_target_type() const;

 public:
    const python::type_info target_type;


    lvalue_from_python_chain* lvalue_chain;


    rvalue_from_python_chain* rvalue_chain;


    PyTypeObject* m_class_object;


    to_python_function_t m_to_python;
    PyTypeObject const* (*m_to_python_target_type)();




    const bool is_shared_ptr;





};




inline registration::registration(type_info target_type, bool is_shared_ptr)
    : target_type(target_type)
      , lvalue_chain(0)
      , rvalue_chain(0)
      , m_class_object(0)
      , m_to_python(0)
      , m_to_python_target_type(0)
      , is_shared_ptr(is_shared_ptr)
{}

inline bool operator<(registration const& lhs, registration const& rhs)
{
    return lhs.target_type < rhs.target_type;
}

}}}
# 10 "/usr/include/boost-1_42/boost/python/converter/registered.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/transform_traits.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/transform_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/add_pointer.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/add_pointer.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/add_pointer.hpp" 2

namespace boost {

namespace detail {
# 55 "/usr/include/boost-1_42/boost/type_traits/add_pointer.hpp"
template <typename T>
struct add_pointer_impl
{
    typedef typename remove_reference<T>::type no_ref_type;
    typedef no_ref_type* type;
};



}

template< typename T > struct add_pointer { typedef typename boost::detail::add_pointer_impl<T>::type type; };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 71 "/usr/include/boost-1_42/boost/type_traits/add_pointer.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/transform_traits.hpp" 2

# 1 "/usr/include/boost-1_42/boost/type_traits/remove_bounds.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/remove_bounds.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 14 "/usr/include/boost-1_42/boost/type_traits/remove_bounds.hpp" 2







# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/remove_bounds.hpp" 2



namespace boost {

template< typename T > struct remove_bounds { typedef T type; };


template< typename T, std::size_t N > struct remove_bounds<T[N]> { typedef T type; };
template< typename T, std::size_t N > struct remove_bounds<T const[N]> { typedef T const type; };
template< typename T, std::size_t N > struct remove_bounds<T volatile[N]> { typedef T volatile type; };
template< typename T, std::size_t N > struct remove_bounds<T const volatile[N]> { typedef T const volatile type; };

template< typename T > struct remove_bounds<T[]> { typedef T type; };
template< typename T > struct remove_bounds<T const[]> { typedef T const type; };
template< typename T > struct remove_bounds<T volatile[]> { typedef T volatile type; };
template< typename T > struct remove_bounds<T const volatile[]> { typedef T const volatile type; };



}



# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 47 "/usr/include/boost-1_42/boost/type_traits/remove_bounds.hpp" 2
# 18 "/usr/include/boost-1_42/boost/type_traits/transform_traits.hpp" 2
# 11 "/usr/include/boost-1_42/boost/python/converter/registered.hpp" 2






namespace boost {




template <class T> class shared_ptr;

namespace python { namespace converter {

struct registration;

namespace detail
{
  template <class T>
  struct registered_base
  {
      static registration const& converters;
  };
}

template <class T>
struct registered
  : detail::registered_base<
        typename add_reference<
            typename add_cv<T>::type
        >::type
    >
{
};







template <class T>
struct registered<T&>
  : registered<T> {};





namespace detail
{
  inline void
  register_shared_ptr0(...)
  {
  }

  template <class T>
  inline void
  register_shared_ptr0(shared_ptr<T>*)
  {
      registry::lookup_shared_ptr(type_id<shared_ptr<T> >());
  }

  template <class T>
  inline void
  register_shared_ptr1(T const volatile*)
  {
      detail::register_shared_ptr0((T*)0);
  }

  template <class T>
  inline registration const&
  registry_lookup2(T&(*)())
  {
      detail::register_shared_ptr1((T*)0);
      return registry::lookup(type_id<T&>());
  }

  template <class T>
  inline registration const&
  registry_lookup1(type<T>)
  {
      return registry_lookup2((T(*)())0);
  }

  inline registration const&
  registry_lookup1(type<const volatile void>)
  {
      detail::register_shared_ptr1((void*)0);
      return registry::lookup(type_id<void>());
  }

  template <class T>
  registration const& registered_base<T>::converters = detail::registry_lookup1(type<T>());

}

}}}
# 11 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/decref_guard.hpp" 1







namespace boost { namespace python { namespace detail {

struct decref_guard
{
    decref_guard(PyObject* o) : obj(o) {}
    ~decref_guard() { if ((obj) == __null) ; else if ( --((PyObject*)(obj))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(obj)))); }
    void cancel() { obj = 0; }
 private:
    PyObject* obj;
};

}}}
# 12 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/none.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/detail/none.hpp"
namespace boost { namespace python { namespace detail {

inline PyObject* none() { ( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++); return (&_Py_NoneStruct); }

}}}
# 13 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp" 2

namespace boost { namespace python { namespace objects {

template <class T, class Holder, class Derived>
struct make_instance_impl
{
    typedef objects::instance<Holder> instance_t;

    template <class Arg>
    static inline PyObject* execute(Arg& x)
    {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((is_class<T>::value) == 0 ? false : true) >)> boost_static_assert_typedef_24;

        PyTypeObject* type = Derived::get_class_object(x);

        if (type == 0)
            return python::detail::none();

        PyObject* raw_result = type->tp_alloc(
            type, objects::additional_instance_size<Holder>::value);

        if (raw_result != 0)
        {
            python::detail::decref_guard protect(raw_result);

            instance_t* instance = (instance_t*)raw_result;



            Derived::construct(&instance->storage, (PyObject*)instance, x)->install(raw_result);



            (((PyVarObject*)(instance))->ob_size) = __builtin_offsetof (instance_t, storage);


            protect.cancel();
        }
        return raw_result;
    }
};


template <class T, class Holder>
struct make_instance
    : make_instance_impl<T, Holder, make_instance<T,Holder> >
{
    template <class U>
    static inline PyTypeObject* get_class_object(U&)
    {
        return converter::registered<T>::converters.get_class_object();
    }

    static inline Holder* construct(void* storage, PyObject* instance, reference_wrapper<T const> x)
    {
        return new (storage) Holder(instance, x);
    }
};


}}}
# 9 "/usr/include/boost-1_42/boost/python/object/make_ptr_instance.hpp" 2






namespace boost { namespace python { namespace objects {

template <class T, class Holder>
struct make_ptr_instance
    : make_instance_impl<T, Holder, make_ptr_instance<T,Holder> >
{
    template <class Arg>
    static inline Holder* construct(void* storage, PyObject*, Arg& x)
    {
        return new (storage) Holder(x);
    }

    template <class Ptr>
    static inline PyTypeObject* get_class_object(Ptr const& x)
    {
        return get_class_object_impl(get_pointer(x));
    }

    static inline PyTypeObject const* get_pytype()
    {
        return converter::registered<T>::converters.get_class_object();
    }

 private:
    template <class U>
    static inline PyTypeObject* get_class_object_impl(U const volatile* p)
    {
        if (p == 0)
            return 0;

        PyTypeObject* derived = get_derived_class_object(
            typename is_polymorphic<U>::type(), p);

        if (derived)
            return derived;
        return converter::registered<T>::converters.get_class_object();
    }

    template <class U>
    static inline PyTypeObject* get_derived_class_object(mpl::true_, U const volatile* x)
    {
        converter::registration const* r = converter::registry::query(
            type_info(typeid(*get_pointer(x)))
        );
        return r ? r->m_class_object : 0;
    }

    template <class U>
    static inline PyTypeObject* get_derived_class_object(mpl::false_, U*)
    {
        return 0;
    }
};


}}}
# 12 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/converter/pytype_function.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/converter/pytype_function.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/unwind_type.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/detail/cv_category.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/detail/cv_category.hpp"
namespace boost { namespace python { namespace detail {

template <bool is_const_, bool is_volatile_>
struct cv_tag
{
    static const bool is_const = is_const_;
    static const bool is_volatile = is_const_;
};

typedef cv_tag<false,false> cv_unqualified;
typedef cv_tag<true,false> const_;
typedef cv_tag<false,true> volatile_;
typedef cv_tag<true,true> const_volatile_;

template <class T>
struct cv_category
{


    typedef cv_tag<
        ::boost::is_const<T>::value
      , ::boost::is_volatile<T>::value
    > type;
};

}}}
# 9 "/usr/include/boost-1_42/boost/python/detail/unwind_type.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/indirect_traits.hpp" 1






# 1 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp" 1
# 25 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/and.hpp" 1
# 42 "/usr/include/boost-1_42/boost/mpl/and.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/and.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/and.hpp"
namespace boost { namespace mpl {

namespace aux {

template< bool C_, typename T1, typename T2, typename T3, typename T4 >
struct and_impl
    : false_
{
};

template< typename T1, typename T2, typename T3, typename T4 >
struct and_impl< true,T1,T2,T3,T4 >
    : and_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4
        , true_
        >
{
};

template<>
struct and_impl<
          true
        , true_, true_, true_, true_
        >
    : true_
{
};

}

template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = true_, typename T4 = true_, typename T5 = true_
    >
struct and_

    : aux::and_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4, T5
        >

{
   




};

template<> struct and_<



 na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : and_< T1 , T2 > { }; }; template< typename Tag > struct lambda< and_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef and_< na , na > result_; typedef and_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< and_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< and_< na , na > > : int_<-1> { }; }

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 43 "/usr/include/boost-1_42/boost/mpl/and.hpp" 2
# 26 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp" 2







namespace boost { namespace detail {

namespace indirect_traits {


template <class T>
struct is_reference_to_const : mpl::false_
{
};

template <class T>
struct is_reference_to_const<T const&> : mpl::true_
{
};
# 55 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp"
template <class T>
struct is_reference_to_function : mpl::false_
{
};

template <class T>
struct is_reference_to_function<T&> : is_function<T>
{
};

template <class T>
struct is_pointer_to_function : mpl::false_
{
};



template <class T>
struct is_pointer_to_function<T*> : is_function<T>
{
};

template <class T>
struct is_reference_to_member_function_pointer_impl : mpl::false_
{
};

template <class T>
struct is_reference_to_member_function_pointer_impl<T&>
    : is_member_function_pointer<typename remove_cv<T>::type>
{
};


template <class T>
struct is_reference_to_member_function_pointer
    : is_reference_to_member_function_pointer_impl<T>
{
   
};

template <class T>
struct is_reference_to_function_pointer_aux
    : mpl::and_<
          is_reference<T>
        , is_pointer_to_function<
              typename remove_cv<
                  typename remove_reference<T>::type
              >::type
          >
      >
{

};

template <class T>
struct is_reference_to_function_pointer
    : mpl::if_<
          is_reference_to_function<T>
        , mpl::false_
        , is_reference_to_function_pointer_aux<T>
     >::type
{
};

template <class T>
struct is_reference_to_non_const
    : mpl::and_<
          is_reference<T>
        , mpl::not_<
             is_reference_to_const<T>
          >
      >
{
};

template <class T>
struct is_reference_to_volatile : mpl::false_
{
};

template <class T>
struct is_reference_to_volatile<T volatile&> : mpl::true_
{
};
# 149 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp"
template <class T>
struct is_reference_to_pointer : mpl::false_
{
};

template <class T>
struct is_reference_to_pointer<T*&> : mpl::true_
{
};

template <class T>
struct is_reference_to_pointer<T* const&> : mpl::true_
{
};

template <class T>
struct is_reference_to_pointer<T* volatile&> : mpl::true_
{
};

template <class T>
struct is_reference_to_pointer<T* const volatile&> : mpl::true_
{
};

template <class T>
struct is_reference_to_class
    : mpl::and_<
          is_reference<T>
        , is_class<
              typename remove_cv<
                  typename remove_reference<T>::type
              >::type
          >
      >
{
   
};

template <class T>
struct is_pointer_to_class
    : mpl::and_<
          is_pointer<T>
        , is_class<
              typename remove_cv<
                  typename remove_pointer<T>::type
              >::type
          >
      >
{
   
};
# 481 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp"
}

using namespace indirect_traits;

}}
# 8 "/usr/include/boost-1_42/boost/python/detail/indirect_traits.hpp" 2

namespace boost { namespace python {
namespace indirect_traits = boost::detail::indirect_traits;
}}
# 10 "/usr/include/boost-1_42/boost/python/detail/unwind_type.hpp" 2


namespace boost { namespace python { namespace detail {



template <class Generator, class U>
inline typename Generator::result_type
unwind_type(U const& p, Generator* = 0);


template <class Generator, class U>
inline typename Generator::result_type
unwind_type(boost::type<U>*p = 0, Generator* = 0);


template <class Generator, class U>
inline typename Generator::result_type
unwind_type_cv(U* p, cv_unqualified, Generator* = 0)
{
    return Generator::execute(p);
}

template <class Generator, class U>
inline typename Generator::result_type
unwind_type_cv(U const* p, const_, Generator* = 0)
{
    return unwind_type(const_cast<U*>(p), (Generator*)0);
}

template <class Generator, class U>
inline typename Generator::result_type
unwind_type_cv(U volatile* p, volatile_, Generator* = 0)
{
    return unwind_type(const_cast<U*>(p), (Generator*)0);
}

template <class Generator, class U>
inline typename Generator::result_type
unwind_type_cv(U const volatile* p, const_volatile_, Generator* = 0)
{
    return unwind_type(const_cast<U*>(p), (Generator*)0);
}

template <class Generator, class U>
inline typename Generator::result_type
unwind_ptr_type(U* p, Generator* = 0)
{
    typedef typename cv_category<U>::type tag;
    return unwind_type_cv<Generator>(p, tag());
}

template <bool is_ptr>
struct unwind_helper
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U p, Generator* = 0)
    {
        return unwind_ptr_type(p, (Generator*)0);
    }
};

template <>
struct unwind_helper<false>
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U& p, Generator* = 0)
    {
        return unwind_ptr_type(&p, (Generator*)0);
    }
};

template <class Generator, class U>
inline typename Generator::result_type

unwind_type(U const& p, Generator*)



{
    return unwind_helper<is_pointer<U>::value>::execute(p, (Generator*)0);
}

enum { direct_ = 0, pointer_ = 1, reference_ = 2, reference_to_pointer_ = 3 };
template <int indirection> struct unwind_helper2;

template <>
struct unwind_helper2<direct_>
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U(*)(), Generator* = 0)
    {
        return unwind_ptr_type((U*)0, (Generator*)0);
    }
};

template <>
struct unwind_helper2<pointer_>
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U*(*)(), Generator* = 0)
    {
        return unwind_ptr_type((U*)0, (Generator*)0);
    }
};

template <>
struct unwind_helper2<reference_>
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U&(*)(), Generator* = 0)
    {
        return unwind_ptr_type((U*)0, (Generator*)0);
    }
};

template <>
struct unwind_helper2<reference_to_pointer_>
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U&(*)(), Generator* = 0)
    {
        return unwind_ptr_type(U(0), (Generator*)0);
    }
};
# 149 "/usr/include/boost-1_42/boost/python/detail/unwind_type.hpp"
template <class Generator, class U>
inline typename Generator::result_type

unwind_type(boost::type<U>*, Generator*)



{
    static const int indirection = (boost::is_pointer<U>::value ? pointer_ : 0) + (indirect_traits::is_reference_to_pointer<U>::value ? reference_to_pointer_ : boost::is_reference<U>::value ? reference_ : 0)





                                  ;

    return unwind_helper2<indirection>::execute((U(*)())0,(Generator*)0);
}

}}}
# 11 "/usr/include/boost-1_42/boost/python/converter/pytype_function.hpp" 2


namespace boost { namespace python {

namespace converter
{
template <PyTypeObject const* python_type>
struct wrap_pytype
{
    static PyTypeObject const* get_pytype()
    {
        return python_type;
    }
};

typedef PyTypeObject const* (*pytype_function)();





namespace detail
{
struct unwind_type_id_helper{
    typedef python::type_info result_type;
    template <class U>
    static result_type execute(U* ){
        return python::type_id<U>();
    }
};

template <class T>
inline python::type_info unwind_type_id_(boost::type<T>* = 0, mpl::false_ * =0)
{
    return boost::python::detail::unwind_type<unwind_type_id_helper, T> ();
}

inline python::type_info unwind_type_id_(boost::type<void>* = 0, mpl::true_* =0)
{
    return type_id<void>();
}

template <class T>
inline python::type_info unwind_type_id(boost::type<T>* p= 0)
{
    return unwind_type_id_(p, (mpl::bool_<boost::is_void<T>::value >*)0 );
}
}


template <class T>
struct expected_pytype_for_arg
{
    static PyTypeObject const *get_pytype()
    {
        const converter::registration *r=converter::registry::query(
            detail::unwind_type_id_((boost::type<T>*)0, (mpl::bool_<boost::is_void<T>::value >*)0 )
            );
        return r ? r->expected_from_python_type(): 0;
    }
};


template <class T>
struct registered_pytype
{
    static PyTypeObject const *get_pytype()
    {
        const converter::registration *r=converter::registry::query(
            detail::unwind_type_id_((boost::type<T>*) 0, (mpl::bool_<boost::is_void<T>::value >*)0 )
            );
        return r ? r->m_class_object: 0;
    }
};


template <class T>
struct registered_pytype_direct
{
    static PyTypeObject const* get_pytype()
    {
        return registered<T>::converters.m_class_object;
    }
};

template <class T>
struct expected_from_python_type : expected_pytype_for_arg<T>{};

template <class T>
struct expected_from_python_type_direct
{
    static PyTypeObject const* get_pytype()
    {
        return registered<T>::converters.expected_from_python_type();
    }
};

template <class T>
struct to_python_target_type
{
    static PyTypeObject const *get_pytype()
    {
        const converter::registration *r=converter::registry::query(
            detail::unwind_type_id_((boost::type<T>*)0, (mpl::bool_<boost::is_void<T>::value >*)0 )
            );
        return r ? r->to_python_target_type(): 0;
    }
};

template <class T>
struct to_python_target_type_direct
{
    static PyTypeObject const *get_pytype()
    {
        return registered<T>::converters.to_python_target_type();
    }
};


}}}
# 17 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp" 2
# 32 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp"
namespace boost { namespace python {

template <class T, class MakeHolder>
struct to_python_indirect
{
    template <class U>
    inline PyObject*
    operator()(U const& ref) const
    {
        return this->execute(const_cast<U&>(ref), is_pointer<U>());
    }

    inline PyTypeObject const*
    get_pytype()const
    {
        return converter::registered_pytype<T>::get_pytype();
    }

 private:
    template <class U>
    inline PyObject* execute(U* ptr, mpl::true_) const
    {

        if (ptr == 0)
            return python::detail::none();
        else
            return this->execute(*ptr, mpl::false_());
    }

    template <class U>
    inline PyObject* execute(U const& x, mpl::false_) const
    {
        U* const p = &const_cast<U&>(x);
        if (is_polymorphic<U>::value)
        {
            if (PyObject* o = detail::wrapper_base_::owner(p))
                return incref(o);
        }
        return MakeHolder::execute(p);
    }
};




namespace detail
{
  struct make_owning_holder
  {
      template <class T>
      static PyObject* execute(T* p)
      {






          typedef std::auto_ptr<T> smart_pointer;

          typedef objects::pointer_holder<smart_pointer, T> holder_t;

          smart_pointer ptr(const_cast<T*>(p));
          return objects::make_ptr_instance<T, holder_t>::execute(ptr);
      }
  };

  struct make_reference_holder
  {
      template <class T>
      static PyObject* execute(T* p)
      {
          typedef objects::pointer_holder<T*, T> holder_t;
          T* q = const_cast<T*>(p);
          return objects::make_ptr_instance<T, holder_t>::execute(q);
      }
  };
}

}}
# 11 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2


# 1 "/usr/include/boost-1_42/boost/python/converter/registered_pointee.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/converter/pointer_type_id.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/converter/pointer_type_id.hpp"
namespace boost { namespace python { namespace converter {

namespace detail
{
  template <bool is_ref = false>
  struct pointer_typeid_select
  {
      template <class T>
      static inline type_info execute(T*(*)() = 0)
      {
          return type_id<T>();
      }
  };

  template <>
  struct pointer_typeid_select<true>
  {
      template <class T>
      static inline type_info execute(T* const volatile&(*)() = 0)
      {
          return type_id<T>();
      }

      template <class T>
      static inline type_info execute(T*volatile&(*)() = 0)
      {
          return type_id<T>();
      }

      template <class T>
      static inline type_info execute(T*const&(*)() = 0)
      {
          return type_id<T>();
      }

      template <class T>
      static inline type_info execute(T*&(*)() = 0)
      {
          return type_id<T>();
      }
  };
}





template <class T>
type_info pointer_type_id(T(*)() = 0)
{
    return detail::pointer_typeid_select<
          is_reference<T>::value
        >::execute((T(*)())0);
}

}}}
# 9 "/usr/include/boost-1_42/boost/python/converter/registered_pointee.hpp" 2




namespace boost { namespace python { namespace converter {

struct registration;


template <class T>
struct registered_pointee
    : registered<
        typename remove_pointer<
           typename remove_cv<
              typename remove_reference<T>::type
           >::type
        >::type
    >
{
};
# 60 "/usr/include/boost-1_42/boost/python/converter/registered_pointee.hpp"
}}}
# 14 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/converter/arg_to_python_base.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/converter/arg_to_python_base.hpp"
namespace boost { namespace python { namespace converter {

struct registration;

namespace detail
{
  struct arg_to_python_base

      : handle<>

  {
      arg_to_python_base(void const volatile* source, registration const&);






  };
}

}}}
# 15 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_to_python.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_to_python.hpp"
# 1 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_deleter.hpp" 1







namespace boost { namespace python { namespace converter {

struct shared_ptr_deleter
{
    shared_ptr_deleter(handle<> owner);
    ~shared_ptr_deleter();

    void operator()(void const*);

    handle<> owner;
};

}}}
# 10 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_to_python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/shared_ptr.hpp" 1
# 17 "/usr/include/boost-1_42/boost/shared_ptr.hpp"
# 1 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 1
# 29 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
# 1 "/usr/include/boost-1_42/boost/assert.hpp" 1
# 36 "/usr/include/boost-1_42/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 37 "/usr/include/boost-1_42/boost/assert.hpp" 2
# 30 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2


# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp" 1
# 28 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
# 1 "/usr/include/boost-1_42/boost/smart_ptr/bad_weak_ptr.hpp" 1
# 26 "/usr/include/boost-1_42/boost/smart_ptr/bad_weak_ptr.hpp"
namespace boost
{
# 39 "/usr/include/boost-1_42/boost/smart_ptr/bad_weak_ptr.hpp"
class bad_weak_ptr: public std::exception
{
public:

    virtual char const * what() const throw()
    {
        return "tr1::bad_weak_ptr";
    }
};





}
# 29 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp" 2
# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base.hpp" 1
# 21 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base.hpp"
# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_has_sync.hpp" 1
# 22 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base.hpp" 2
# 36 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base.hpp"
# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 1
# 29 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp"
namespace boost
{

namespace detail
{

inline int atomic_exchange_and_add( int * pw, int dv )
{




    int r;

    __asm__ __volatile__
    (
        "lock\n\t"
        "xadd %1, %0":
        "=m"( *pw ), "=r"( r ):
        "m"( *pw ), "1"( dv ):
        "memory", "cc"
    );

    return r;
}

inline void atomic_increment( int * pw )
{


    __asm__
    (
        "lock\n\t"
        "incl %0":
        "=m"( *pw ):
        "m"( *pw ):
        "cc"
    );
}

inline int atomic_conditional_increment( int * pw )
{




    int rv, tmp;

    __asm__
    (
        "movl %0, %%eax\n\t"
        "0:\n\t"
        "test %%eax, %%eax\n\t"
        "je 1f\n\t"
        "movl %%eax, %2\n\t"
        "incl %2\n\t"
        "lock\n\t"
        "cmpxchgl %2, %0\n\t"
        "jne 0b\n\t"
        "1:":
        "=m"( *pw ), "=&a"( rv ), "=&r"( tmp ):
        "m"( *pw ):
        "cc"
    );

    return rv;
}

class sp_counted_base
{
private:

    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );

    int use_count_;
    int weak_count_;

public:

    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }

    virtual ~sp_counted_base()
    {
    }




    virtual void dispose() = 0;



    virtual void destroy()
    {
        delete this;
    }

    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;

    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }

    bool add_ref_lock()
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }

    void release()
    {
        if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
        {
            dispose();
            weak_release();
        }
    }

    void weak_add_ref()
    {
        atomic_increment( &weak_count_ );
    }

    void weak_release()
    {
        if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
        {
            destroy();
        }
    }

    long use_count() const
    {
        return static_cast<int const volatile &>( use_count_ );
    }
};

}

}
# 37 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base.hpp" 2
# 30 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp" 2
# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp" 1
# 38 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 39 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp" 2

namespace boost
{
# 50 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp"
namespace detail
{

template<class X> class sp_counted_impl_p: public sp_counted_base
{
private:

    X * px_;

    sp_counted_impl_p( sp_counted_impl_p const & );
    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );

    typedef sp_counted_impl_p<X> this_type;

public:

    explicit sp_counted_impl_p( X * px ): px_( px )
    {



    }

    virtual void dispose()
    {



        boost::checked_delete( px_ );
    }

    virtual void * get_deleter( detail::sp_typeinfo const & )
    {
        return 0;
    }
# 113 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp"
};
# 122 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp"
template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
{
private:

    P ptr;
    D del;

    sp_counted_impl_pd( sp_counted_impl_pd const & );
    sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );

    typedef sp_counted_impl_pd<P, D> this_type;

public:



    sp_counted_impl_pd( P p, D d ): ptr(p), del(d)
    {
    }

    virtual void dispose()
    {
        del( ptr );
    }

    virtual void * get_deleter( detail::sp_typeinfo const & ti )
    {
        return ti == typeid(D)? &reinterpret_cast<char&>( del ): 0;
    }
# 179 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp"
};

template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
{
private:

    P p_;
    D d_;
    A a_;

    sp_counted_impl_pda( sp_counted_impl_pda const & );
    sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );

    typedef sp_counted_impl_pda<P, D, A> this_type;

public:



    sp_counted_impl_pda( P p, D d, A a ): p_( p ), d_( d ), a_( a )
    {
    }

    virtual void dispose()
    {
        d_( p_ );
    }

    virtual void destroy()
    {
        typedef typename A::template rebind< this_type >::other A2;

        A2 a2( a_ );

        this->~this_type();
        a2.deallocate( this, 1 );
    }

    virtual void * get_deleter( detail::sp_typeinfo const & ti )
    {
        return ti == typeid(D)? &reinterpret_cast<char&>( d_ ): 0;
    }
};





}

}
# 31 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp" 2
# 40 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
namespace boost
{

namespace detail
{
# 53 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
struct sp_nothrow_tag {};

class weak_count;

class shared_count
{
private:

    sp_counted_base * pi_;





    friend class weak_count;

public:

    shared_count(): pi_(0)



    {
    }

    template<class Y> explicit shared_count( Y * p ): pi_( 0 )



    {


        try
        {
            pi_ = new sp_counted_impl_p<Y>( p );
        }
        catch(...)
        {
            boost::checked_delete( p );
            throw;
        }
# 106 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
    }




    template<class P, class D> shared_count( P p, D d ): pi_(0)




    {





        try
        {
            pi_ = new sp_counted_impl_pd<P, D>(p, d);
        }
        catch(...)
        {
            d(p);
            throw;
        }
# 143 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
    }

    template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )



    {
        typedef sp_counted_impl_pda<P, D, A> impl_type;
        typedef typename A::template rebind< impl_type >::other A2;

        A2 a2( a );



        try
        {
            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
            new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
        }
        catch(...)
        {
            d( p );

            if( pi_ != 0 )
            {
                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
            }

            throw;
        }
# 189 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
    }





    template<class Y>
    explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )



    {
# 210 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
        r.release();
    }



    ~shared_count()
    {
        if( pi_ != 0 ) pi_->release();



    }

    shared_count(shared_count const & r): pi_(r.pi_)



    {
        if( pi_ != 0 ) pi_->add_ref_copy();
    }
# 243 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
    explicit shared_count(weak_count const & r);
    shared_count( weak_count const & r, sp_nothrow_tag );

    shared_count & operator= (shared_count const & r)
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if( tmp != 0 ) tmp->add_ref_copy();
            if( pi_ != 0 ) pi_->release();
            pi_ = tmp;
        }

        return *this;
    }

    void swap(shared_count & r)
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool unique() const
    {
        return use_count() == 1;
    }

    bool empty() const
    {
        return pi_ == 0;
    }

    friend inline bool operator==(shared_count const & a, shared_count const & b)
    {
        return a.pi_ == b.pi_;
    }

    friend inline bool operator<(shared_count const & a, shared_count const & b)
    {
        return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
    }

    void * get_deleter( sp_typeinfo const & ti ) const
    {
        return pi_? pi_->get_deleter( ti ): 0;
    }
};


class weak_count
{
private:

    sp_counted_base * pi_;





    friend class shared_count;

public:

    weak_count(): pi_(0)



    {
    }

    weak_count(shared_count const & r): pi_(r.pi_)



    {
        if(pi_ != 0) pi_->weak_add_ref();
    }

    weak_count(weak_count const & r): pi_(r.pi_)



    {
        if(pi_ != 0) pi_->weak_add_ref();
    }
# 350 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
    ~weak_count()
    {
        if(pi_ != 0) pi_->weak_release();



    }

    weak_count & operator= (shared_count const & r)
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if(tmp != 0) tmp->weak_add_ref();
            if(pi_ != 0) pi_->weak_release();
            pi_ = tmp;
        }

        return *this;
    }

    weak_count & operator= (weak_count const & r)
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if(tmp != 0) tmp->weak_add_ref();
            if(pi_ != 0) pi_->weak_release();
            pi_ = tmp;
        }

        return *this;
    }

    void swap(weak_count & r)
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool empty() const
    {
        return pi_ == 0;
    }

    friend inline bool operator==(weak_count const & a, weak_count const & b)
    {
        return a.pi_ == b.pi_;
    }

    friend inline bool operator<(weak_count const & a, weak_count const & b)
    {
        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
    }
};

inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )



{
    if( pi_ == 0 || !pi_->add_ref_lock() )
    {
        boost::throw_exception( boost::bad_weak_ptr() );
    }
}

inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )



{
    if( pi_ != 0 && !pi_->add_ref_lock() )
    {
        pi_ = 0;
    }
}

}

}
# 33 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2

# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_convertible.hpp" 1
# 34 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_convertible.hpp"
namespace boost
{

namespace detail
{

template< class Y, class T > struct sp_convertible
{
    typedef char (&yes) [1];
    typedef char (&no) [2];

    static yes f( T* );
    static no f( ... );

    enum _vt { value = sizeof( f( static_cast<Y*>(0) ) ) == sizeof(yes) };
};

struct sp_empty
{
};

template< bool > struct sp_enable_if_convertible_impl;

template<> struct sp_enable_if_convertible_impl<true>
{
    typedef sp_empty type;
};

template<> struct sp_enable_if_convertible_impl<false>
{
};

template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
{
};

}

}
# 35 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2


# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_pool.hpp" 1
# 25 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_pool.hpp"
# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock.hpp" 1
# 38 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock.hpp"
# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_sync.hpp" 1
# 18 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_sync.hpp"
# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/yield_k.hpp" 1
# 91 "/usr/include/boost-1_42/boost/smart_ptr/detail/yield_k.hpp"
namespace boost
{

namespace detail
{

inline void yield( unsigned k )
{
    if( k < 4 )
    {
    }

    else if( k < 16 )
    {
        __asm__ __volatile__( "rep; nop" : : : "memory" );
    }

    else if( k < 32 || k & 1 )
    {
        sched_yield();
    }
    else
    {

        struct timespec rqtp = { 0, 0 };




        rqtp.tv_sec = 0;
        rqtp.tv_nsec = 1000;

        nanosleep( &rqtp, 0 );
    }
}

}

}
# 19 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_sync.hpp" 2





namespace boost
{

namespace detail
{

class spinlock
{
public:

    int v_;

public:

    bool try_lock()
    {
        int r = __sync_lock_test_and_set( &v_, 1 );
        return r == 0;
    }

    void lock()
    {
        for( unsigned k = 0; !try_lock(); ++k )
        {
            boost::detail::yield( k );
        }
    }

    void unlock()
    {
        __sync_lock_release( &v_ );
    }

public:

    class scoped_lock
    {
    private:

        spinlock & sp_;

        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );

    public:

        explicit scoped_lock( spinlock & sp ): sp_( sp )
        {
            sp.lock();
        }

        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
};

}
}
# 39 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock.hpp" 2
# 26 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_pool.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 27 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_pool.hpp" 2

namespace boost
{

namespace detail
{

template< int I > class spinlock_pool
{
private:

    static spinlock pool_[ 41 ];

public:

    static spinlock & spinlock_for( void const * pv )
    {
        std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
        return pool_[ i ];
    }

    class scoped_lock
    {
    private:

        spinlock & sp_;

        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );

    public:

        explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
        {
            sp_.lock();
        }

        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
};

template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
{
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}
};

}
}
# 38 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2
# 1 "/usr/include/boost-1_42/boost/memory_order.hpp" 1
# 21 "/usr/include/boost-1_42/boost/memory_order.hpp"
namespace boost
{
# 41 "/usr/include/boost-1_42/boost/memory_order.hpp"
enum memory_order
{
    memory_order_relaxed = 0,
    memory_order_acquire = 1,
    memory_order_release = 2,
    memory_order_acq_rel = 3,
    memory_order_seq_cst = 7,
    memory_order_consume = 8
};

}
# 39 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2
# 58 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
namespace boost
{

template<class T> class shared_ptr;
template<class T> class weak_ptr;
template<class T> class enable_shared_from_this;
template<class T> class enable_shared_from_this2;

namespace detail
{

struct static_cast_tag {};
struct const_cast_tag {};
struct dynamic_cast_tag {};
struct polymorphic_cast_tag {};

template<class T> struct shared_ptr_traits
{
    typedef T & reference;
};

template<> struct shared_ptr_traits<void>
{
    typedef void reference;
};



template<> struct shared_ptr_traits<void const>
{
    typedef void reference;
};

template<> struct shared_ptr_traits<void volatile>
{
    typedef void reference;
};

template<> struct shared_ptr_traits<void const volatile>
{
    typedef void reference;
};





template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}

template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_this2< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}
# 136 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
inline void sp_enable_shared_from_this( ... )
{
}







template< class T, class R > struct sp_enable_if_auto_ptr
{
};

template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
{
    typedef R type;
};



}
# 168 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
template<class T> class shared_ptr
{
private:


    typedef shared_ptr<T> this_type;

public:

    typedef T element_type;
    typedef T value_type;
    typedef T * pointer;
    typedef typename boost::detail::shared_ptr_traits<T>::reference reference;

    shared_ptr(): px(0), pn()
    {
    }

    template<class Y>
    explicit shared_ptr( Y * p ): px( p ), pn( p )
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }







    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }



    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }



    template<class Y>
    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn)
    {

        px = r.px;
    }

    template<class Y>
    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
    {
        if( !pn.empty() )
        {
            px = r.px;
        }
    }

    template<class Y>


    shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )






    : px( r.px ), pn( r.pn )
    {
    }


    template< class Y >
    shared_ptr( shared_ptr<Y> const & r, T * p ): px( p ), pn( r.pn )
    {
    }

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
    {
    }

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
    {
    }

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0)
        {
            pn = boost::detail::shared_count();
        }
    }

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0)
        {
            boost::throw_exception(std::bad_cast());
        }
    }



    template<class Y>
    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
    {
        Y * tmp = r.get();
        pn = boost::detail::shared_count(r);
        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
    }



    template<class Ap>
    explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 ): px( r.get() ), pn()
    {
        typename Ap::element_type * tmp = r.get();
        pn = boost::detail::shared_count( r );
        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
    }
# 303 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
    shared_ptr & operator=( shared_ptr const & r )
    {
        this_type(r).swap(*this);
        return *this;
    }



    template<class Y>
    shared_ptr & operator=(shared_ptr<Y> const & r)
    {
        this_type(r).swap(*this);
        return *this;
    }





    template<class Y>
    shared_ptr & operator=( std::auto_ptr<Y> & r )
    {
        this_type(r).swap(*this);
        return *this;
    }



    template<class Ap>
    typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r )
    {
        this_type( r ).swap( *this );
        return *this;
    }
# 384 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
    void reset()
    {
        this_type().swap(*this);
    }

    template<class Y> void reset(Y * p)
    {
        (static_cast<void> (0));
        this_type(p).swap(*this);
    }

    template<class Y, class D> void reset( Y * p, D d )
    {
        this_type( p, d ).swap( *this );
    }

    template<class Y, class D, class A> void reset( Y * p, D d, A a )
    {
        this_type( p, d, a ).swap( *this );
    }

    template<class Y> void reset( shared_ptr<Y> const & r, T * p )
    {
        this_type( r, p ).swap( *this );
    }

    reference operator* () const
    {
        (static_cast<void> (0));
        return *px;
    }

    T * operator-> () const
    {
        (static_cast<void> (0));
        return px;
    }

    T * get() const
    {
        return px;
    }


# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/operator_bool.hpp" 1
# 43 "/usr/include/boost-1_42/boost/smart_ptr/detail/operator_bool.hpp"
    typedef T * this_type::*unspecified_bool_type;

    operator unspecified_bool_type() const
    {
        return px == 0? 0: &this_type::px;
    }




    bool operator! () const
    {
        return px == 0;
    }
# 429 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2

    bool unique() const
    {
        return pn.unique();
    }

    long use_count() const
    {
        return pn.use_count();
    }

    void swap(shared_ptr<T> & other)
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
    {
        return pn < rhs.pn;
    }

    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const
    {
        return pn.get_deleter( ti );
    }

    bool _internal_equiv( shared_ptr const & r ) const
    {
        return px == r.px && pn == r.pn;
    }






private:

    template<class Y> friend class shared_ptr;
    template<class Y> friend class weak_ptr;




    T * px;
    boost::detail::shared_count pn;

};

template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() == b.get();
}

template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() != b.get();
}
# 500 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a._internal_less(b);
}

template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
{
    a.swap(b);
}

template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::static_cast_tag());
}

template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::const_cast_tag());
}

template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
}



template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::static_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::polymorphic_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
{
    (static_cast<void> (0));
    return shared_static_cast<T>(r);
}



template<class T> inline T * get_pointer(shared_ptr<T> const & p)
{
    return p.get();
}
# 577 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)

{
    os << p.get();
    return os;
}
# 607 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
{
    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
}







template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * )
{
    return false;
}

template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    return *p;
}

template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order )
{
    return atomic_load( p );
}

template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    p->swap( r );
}

template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
    atomic_store( p, r );
}

template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();
    p->swap( r );
    sp.unlock();

    return r;
}

template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
    return atomic_exchange( p, r );
}

template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();

    if( p->_internal_equiv( *v ) )
    {
        p->swap( w );

        sp.unlock();

        return true;
    }
    else
    {
        shared_ptr<T> tmp( *p );

        sp.unlock();

        tmp.swap( *v );
        return false;
    }
}

template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order , memory_order )
{
    return atomic_compare_exchange( p, v, w );
}



}
# 18 "/usr/include/boost-1_42/boost/shared_ptr.hpp" 2
# 11 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_to_python.hpp" 2


namespace boost { namespace python { namespace converter {

template <class T>
PyObject* shared_ptr_to_python(shared_ptr<T> const& x)
{
    if (!x)
        return python::detail::none();
    else if (shared_ptr_deleter* d = boost::get_deleter<shared_ptr_deleter>(x))
        return incref( get_pointer( d->owner ) );
    else
        return converter::registered<shared_ptr<T> const&>::converters.to_python(&x);
}

}}}
# 16 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp"
# 1 "/usr/include/boost-1_42/boost/python/ssize_t.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/ssize_t.hpp"
namespace boost { namespace python {



typedef Py_ssize_t ssize_t;
ssize_t const ssize_t_max = ((Py_ssize_t)(((size_t)-1)>>1));
ssize_t const ssize_t_min = (-((Py_ssize_t)(((size_t)-1)>>1))-1);
# 27 "/usr/include/boost-1_42/boost/python/ssize_t.hpp"
}}
# 11 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp" 2
# 1 "/usr/include/boost-1_42/boost/implicit_cast.hpp" 1







# 1 "/usr/include/boost-1_42/boost/mpl/identity.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/identity.hpp"
namespace boost { namespace mpl {

template<
      typename T = na
    >
struct identity
{
    typedef T type;
   
};

template<
      typename T = na
    >
struct make_identity
{
    typedef identity<T> type;
   
};

template<> struct identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : identity< T1 > { }; }; template< typename Tag > struct lambda< identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef identity< na > result_; typedef identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< identity< T1 > > : int_<1> { }; template<> struct template_arity< identity< na > > : int_<-1> { }; }
template<> struct make_identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : make_identity< T1 > { }; }; template< typename Tag > struct lambda< make_identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef make_identity< na > result_; typedef make_identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< make_identity< T1 > > : int_<1> { }; template<> struct template_arity< make_identity< na > > : int_<-1> { }; }

}}
# 9 "/usr/include/boost-1_42/boost/implicit_cast.hpp" 2

namespace boost {






template <typename T>
inline T implicit_cast (typename mpl::identity<T>::type x) {
    return x;
}





}
# 12 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
# 77 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
namespace std __attribute__ ((__visibility__ ("default"))) {



  template<typename _Tp>
    _Tp __cmath_power(_Tp, unsigned int);

  template<typename _Tp>
    inline _Tp
    __pow_helper(_Tp __x, int __n)
    {
      return __n < 0
        ? _Tp(1)/__cmath_power(__x, -__n)
        : __cmath_power(__x, __n);
    }

  inline double
  abs(double __x)
  { return __builtin_fabs(__x); }

  inline float
  abs(float __x)
  { return __builtin_fabsf(__x); }

  inline long double
  abs(long double __x)
  { return __builtin_fabsl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    abs(_Tp __x)
    { return __builtin_fabs(__x); }

  using ::acos;

  inline float
  acos(float __x)
  { return __builtin_acosf(__x); }

  inline long double
  acos(long double __x)
  { return __builtin_acosl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    acos(_Tp __x)
    { return __builtin_acos(__x); }

  using ::asin;

  inline float
  asin(float __x)
  { return __builtin_asinf(__x); }

  inline long double
  asin(long double __x)
  { return __builtin_asinl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    asin(_Tp __x)
    { return __builtin_asin(__x); }

  using ::atan;

  inline float
  atan(float __x)
  { return __builtin_atanf(__x); }

  inline long double
  atan(long double __x)
  { return __builtin_atanl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    atan(_Tp __x)
    { return __builtin_atan(__x); }

  using ::atan2;

  inline float
  atan2(float __y, float __x)
  { return __builtin_atan2f(__y, __x); }

  inline long double
  atan2(long double __y, long double __x)
  { return __builtin_atan2l(__y, __x); }

  template<typename _Tp, typename _Up>
    inline
    typename __gnu_cxx::__promote_2<
    typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
        && __is_arithmetic<_Up>::__value,
        _Tp>::__type, _Up>::__type
    atan2(_Tp __y, _Up __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return atan2(__type(__y), __type(__x));
    }

  using ::ceil;

  inline float
  ceil(float __x)
  { return __builtin_ceilf(__x); }

  inline long double
  ceil(long double __x)
  { return __builtin_ceill(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    ceil(_Tp __x)
    { return __builtin_ceil(__x); }

  using ::cos;

  inline float
  cos(float __x)
  { return __builtin_cosf(__x); }

  inline long double
  cos(long double __x)
  { return __builtin_cosl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    cos(_Tp __x)
    { return __builtin_cos(__x); }

  using ::cosh;

  inline float
  cosh(float __x)
  { return __builtin_coshf(__x); }

  inline long double
  cosh(long double __x)
  { return __builtin_coshl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    cosh(_Tp __x)
    { return __builtin_cosh(__x); }

  using ::exp;

  inline float
  exp(float __x)
  { return __builtin_expf(__x); }

  inline long double
  exp(long double __x)
  { return __builtin_expl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    exp(_Tp __x)
    { return __builtin_exp(__x); }

  using ::fabs;

  inline float
  fabs(float __x)
  { return __builtin_fabsf(__x); }

  inline long double
  fabs(long double __x)
  { return __builtin_fabsl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    fabs(_Tp __x)
    { return __builtin_fabs(__x); }

  using ::floor;

  inline float
  floor(float __x)
  { return __builtin_floorf(__x); }

  inline long double
  floor(long double __x)
  { return __builtin_floorl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    floor(_Tp __x)
    { return __builtin_floor(__x); }

  using ::fmod;

  inline float
  fmod(float __x, float __y)
  { return __builtin_fmodf(__x, __y); }

  inline long double
  fmod(long double __x, long double __y)
  { return __builtin_fmodl(__x, __y); }

  using ::frexp;

  inline float
  frexp(float __x, int* __exp)
  { return __builtin_frexpf(__x, __exp); }

  inline long double
  frexp(long double __x, int* __exp)
  { return __builtin_frexpl(__x, __exp); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    frexp(_Tp __x, int* __exp)
    { return __builtin_frexp(__x, __exp); }

  using ::ldexp;

  inline float
  ldexp(float __x, int __exp)
  { return __builtin_ldexpf(__x, __exp); }

  inline long double
  ldexp(long double __x, int __exp)
  { return __builtin_ldexpl(__x, __exp); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
  ldexp(_Tp __x, int __exp)
  { return __builtin_ldexp(__x, __exp); }

  using ::log;

  inline float
  log(float __x)
  { return __builtin_logf(__x); }

  inline long double
  log(long double __x)
  { return __builtin_logl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    log(_Tp __x)
    { return __builtin_log(__x); }

  using ::log10;

  inline float
  log10(float __x)
  { return __builtin_log10f(__x); }

  inline long double
  log10(long double __x)
  { return __builtin_log10l(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    log10(_Tp __x)
    { return __builtin_log10(__x); }

  using ::modf;

  inline float
  modf(float __x, float* __iptr)
  { return __builtin_modff(__x, __iptr); }

  inline long double
  modf(long double __x, long double* __iptr)
  { return __builtin_modfl(__x, __iptr); }

  using ::pow;

  inline float
  pow(float __x, float __y)
  { return __builtin_powf(__x, __y); }

  inline long double
  pow(long double __x, long double __y)
  { return __builtin_powl(__x, __y); }




  inline double
  pow(double __x, int __i)
  { return __builtin_powi(__x, __i); }

  inline float
  pow(float __x, int __n)
  { return __builtin_powif(__x, __n); }

  inline long double
  pow(long double __x, int __n)
  { return __builtin_powil(__x, __n); }


  template<typename _Tp, typename _Up>
    inline
    typename __gnu_cxx::__promote_2<
    typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
        && __is_arithmetic<_Up>::__value,
        _Tp>::__type, _Up>::__type
    pow(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return pow(__type(__x), __type(__y));
    }

  using ::sin;

  inline float
  sin(float __x)
  { return __builtin_sinf(__x); }

  inline long double
  sin(long double __x)
  { return __builtin_sinl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    sin(_Tp __x)
    { return __builtin_sin(__x); }

  using ::sinh;

  inline float
  sinh(float __x)
  { return __builtin_sinhf(__x); }

  inline long double
  sinh(long double __x)
  { return __builtin_sinhl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    sinh(_Tp __x)
    { return __builtin_sinh(__x); }

  using ::sqrt;

  inline float
  sqrt(float __x)
  { return __builtin_sqrtf(__x); }

  inline long double
  sqrt(long double __x)
  { return __builtin_sqrtl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    sqrt(_Tp __x)
    { return __builtin_sqrt(__x); }

  using ::tan;

  inline float
  tan(float __x)
  { return __builtin_tanf(__x); }

  inline long double
  tan(long double __x)
  { return __builtin_tanl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    tan(_Tp __x)
    { return __builtin_tan(__x); }

  using ::tanh;

  inline float
  tanh(float __x)
  { return __builtin_tanhf(__x); }

  inline long double
  tanh(long double __x)
  { return __builtin_tanhl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    tanh(_Tp __x)
    { return __builtin_tanh(__x); }

}
# 498 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    fpclassify(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
      FP_SUBNORMAL, FP_ZERO, __type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isfinite(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isfinite(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isinf(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isinf(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isnan(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isnan(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isnormal(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isnormal(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    signbit(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_signbit(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isgreater(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isgreater(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isgreaterequal(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isless(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isless(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    islessequal(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_islessequal(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    islessgreater(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_islessgreater(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isunordered(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isunordered(__type(__f1), __type(__f2));
    }

}





# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cmath.tcc" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cmath.tcc" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _Tp>
    inline _Tp
    __cmath_power(_Tp __x, unsigned int __n)
    {
      _Tp __y = __n % 2 ? __x : _Tp(1);

      while (__n >>= 1)
        {
          __x = __x * __x;
          if (__n % 2)
            __y = __y * __x;
        }

      return __y;
    }

}
# 616 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 2 3
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3




namespace std __attribute__ ((__visibility__ ("default"))) {
# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;

      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

    protected:

      ios_base::openmode _M_mode;


      __string_type _M_string;

    public:
# 91 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      explicit
      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_mode(__mode), _M_string()
      { }
# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      explicit
      basic_stringbuf(const __string_type& __str,
        ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
      { _M_stringbuf_init(__mode); }
# 119 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      __string_type
      str() const
      {
 __string_type __ret;
 if (this->pptr())
   {

     if (this->pptr() > this->egptr())
       __ret = __string_type(this->pbase(), this->pptr());
     else
        __ret = __string_type(this->pbase(), this->egptr());
   }
 else
   __ret = _M_string;
 return __ret;
      }
# 143 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      void
      str(const __string_type& __s)
      {

 _M_string.assign(__s.data(), __s.size());
 _M_stringbuf_init(_M_mode);
      }

    protected:

      void
      _M_stringbuf_init(ios_base::openmode __mode)
      {
 _M_mode = __mode;
 __size_type __len = 0;
 if (_M_mode & (ios_base::ate | ios_base::app))
   __len = _M_string.size();
 _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
      }

      virtual streamsize
      showmanyc()
      {
 streamsize __ret = -1;
 if (_M_mode & ios_base::in)
   {
     _M_update_egptr();
     __ret = this->egptr() - this->gptr();
   }
 return __ret;
      }

      virtual int_type
      underflow();

      virtual int_type
      pbackfail(int_type __c = traits_type::eof());

      virtual int_type
      overflow(int_type __c = traits_type::eof());
# 195 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      virtual __streambuf_type*
      setbuf(char_type* __s, streamsize __n)
      {
 if (__s && __n >= 0)
   {






     _M_string.clear();


     _M_sync(__s, __n, 0);
   }
 return this;
      }

      virtual pos_type
      seekoff(off_type __off, ios_base::seekdir __way,
       ios_base::openmode __mode = ios_base::in | ios_base::out);

      virtual pos_type
      seekpos(pos_type __sp,
       ios_base::openmode __mode = ios_base::in | ios_base::out);




      void
      _M_sync(char_type* __base, __size_type __i, __size_type __o);



      void
      _M_update_egptr()
      {
 const bool __testin = _M_mode & ios_base::in;
 if (this->pptr() && this->pptr() > this->egptr())
   {
     if (__testin)
       this->setg(this->eback(), this->gptr(), this->pptr());
     else
       this->setg(this->pptr(), this->pptr(), this->pptr());
   }
      }
    };
# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_istringstream : public basic_istream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_istream<char_type, traits_type> __istream_type;

    private:
      __stringbuf_type _M_stringbuf;

    public:
# 291 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      explicit
      basic_istringstream(ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
      { this->init(&_M_stringbuf); }
# 309 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      explicit
      basic_istringstream(const __string_type& __str,
     ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
      { this->init(&_M_stringbuf); }







      ~basic_istringstream()
      { }
# 331 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const
      { return _M_stringbuf.str(); }







      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }
    };
# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
  template <typename _CharT, typename _Traits, typename _Alloc>
    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_ostream<char_type, traits_type> __ostream_type;

    private:
      __stringbuf_type _M_stringbuf;

    public:
# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      explicit
      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
      { this->init(&_M_stringbuf); }
# 419 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      explicit
      basic_ostringstream(const __string_type& __str,
     ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
      { this->init(&_M_stringbuf); }







      ~basic_ostringstream()
      { }
# 441 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const
      { return _M_stringbuf.str(); }







      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }
    };
# 475 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
  template <typename _CharT, typename _Traits, typename _Alloc>
    class basic_stringstream : public basic_iostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_iostream<char_type, traits_type> __iostream_type;

    private:
      __stringbuf_type _M_stringbuf;

    public:
# 509 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      explicit
      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(), _M_stringbuf(__m)
      { this->init(&_M_stringbuf); }
# 525 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      explicit
      basic_stringstream(const __string_type& __str,
    ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(), _M_stringbuf(__str, __m)
      { this->init(&_M_stringbuf); }







      ~basic_stringstream()
      { }
# 547 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const
      { return _M_stringbuf.str(); }







      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }
    };

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/sstream.tcc" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/sstream.tcc" 3
       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/sstream.tcc" 3

namespace std __attribute__ ((__visibility__ ("default"))) {

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    pbackfail(int_type __c)
    {
      int_type __ret = traits_type::eof();
      if (this->eback() < this->gptr())
 {


   const bool __testeof = traits_type::eq_int_type(__c, __ret);
   if (!__testeof)
     {
       const bool __testeq = traits_type::eq(traits_type::
          to_char_type(__c),
          this->gptr()[-1]);
       const bool __testout = this->_M_mode & ios_base::out;
       if (__testeq || __testout)
  {
    this->gbump(-1);
    if (!__testeq)
      *this->gptr() = traits_type::to_char_type(__c);
    __ret = __c;
  }
     }
   else
     {
       this->gbump(-1);
       __ret = traits_type::not_eof(__c);
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    overflow(int_type __c)
    {
      const bool __testout = this->_M_mode & ios_base::out;
      if (__builtin_expect(!__testout, false))
 return traits_type::eof();

      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
      if (__builtin_expect(__testeof, false))
 return traits_type::not_eof(__c);

      const __size_type __capacity = _M_string.capacity();
      const __size_type __max_size = _M_string.max_size();
      const bool __testput = this->pptr() < this->epptr();
      if (__builtin_expect(!__testput && __capacity == __max_size, false))
 return traits_type::eof();



      const char_type __conv = traits_type::to_char_type(__c);
      if (!__testput)
 {
# 110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/sstream.tcc" 3
   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
       __size_type(512));
   const __size_type __len = std::min(__opt_len, __max_size);
   __string_type __tmp;
   __tmp.reserve(__len);
   if (this->pbase())
     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
   __tmp.push_back(__conv);
   _M_string.swap(__tmp);
   _M_sync(const_cast<char_type*>(_M_string.data()),
    this->gptr() - this->eback(), this->pptr() - this->pbase());
 }
      else
 *this->pptr() = __conv;
      this->pbump(1);
      return __c;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    underflow()
    {
      int_type __ret = traits_type::eof();
      const bool __testin = this->_M_mode & ios_base::in;
      if (__testin)
 {

   _M_update_egptr();

   if (this->gptr() < this->egptr())
     __ret = traits_type::to_int_type(*this->gptr());
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
    {
      pos_type __ret = pos_type(off_type(-1));
      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
      const bool __testboth = __testin && __testout && __way != ios_base::cur;
      __testin &= !(__mode & ios_base::out);
      __testout &= !(__mode & ios_base::in);



      const char_type* __beg = __testin ? this->eback() : this->pbase();
      if ((__beg || !__off) && (__testin || __testout || __testboth))
 {
   _M_update_egptr();

   off_type __newoffi = __off;
   off_type __newoffo = __newoffi;
   if (__way == ios_base::cur)
     {
       __newoffi += this->gptr() - __beg;
       __newoffo += this->pptr() - __beg;
     }
   else if (__way == ios_base::end)
     __newoffo = __newoffi += this->egptr() - __beg;

   if ((__testin || __testboth)
       && __newoffi >= 0
       && this->egptr() - __beg >= __newoffi)
     {
       this->gbump((__beg + __newoffi) - this->gptr());
       __ret = pos_type(__newoffi);
     }
   if ((__testout || __testboth)
       && __newoffo >= 0
       && this->egptr() - __beg >= __newoffo)
     {
       this->pbump((__beg + __newoffo) - this->pptr());
       __ret = pos_type(__newoffo);
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    seekpos(pos_type __sp, ios_base::openmode __mode)
    {
      pos_type __ret = pos_type(off_type(-1));
      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;

      const char_type* __beg = __testin ? this->eback() : this->pbase();
      if ((__beg || !off_type(__sp)) && (__testin || __testout))
 {
   _M_update_egptr();

   const off_type __pos(__sp);
   const bool __testpos = (0 <= __pos
      && __pos <= this->egptr() - __beg);
   if (__testpos)
     {
       if (__testin)
  this->gbump((__beg + __pos) - this->gptr());
       if (__testout)
                this->pbump((__beg + __pos) - this->pptr());
       __ret = __sp;
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    void
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    _M_sync(char_type* __base, __size_type __i, __size_type __o)
    {
      const bool __testin = _M_mode & ios_base::in;
      const bool __testout = _M_mode & ios_base::out;
      char_type* __endg = __base + _M_string.size();
      char_type* __endp = __base + _M_string.capacity();

      if (__base != _M_string.data())
 {

   __endg += __i;
   __i = 0;
   __endp = __endg;
 }

      if (__testin)
 this->setg(__base, __base + __i, __endg);
      if (__testout)
 {
   this->setp(__base, __endp);
   this->pbump(__o);



   if (!__testin)
     this->setg(__endg, __endg, __endg);
 }
    }





  extern template class basic_stringbuf<char>;
  extern template class basic_istringstream<char>;
  extern template class basic_ostringstream<char>;
  extern template class basic_stringstream<char>;


  extern template class basic_stringbuf<wchar_t>;
  extern template class basic_istringstream<wchar_t>;
  extern template class basic_ostringstream<wchar_t>;
  extern template class basic_stringstream<wchar_t>;



}
# 574 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 2 3
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
  template<typename _Tp> class complex;
  template<> class complex<float>;
  template<> class complex<double>;
  template<> class complex<long double>;


  template<typename _Tp> _Tp abs(const complex<_Tp>&);

  template<typename _Tp> _Tp arg(const complex<_Tp>&);

  template<typename _Tp> _Tp norm(const complex<_Tp>&);


  template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);



  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);



  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);


  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);

  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
                                          const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
# 121 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
  template<typename _Tp>
    struct complex
    {

      typedef _Tp value_type;



      complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
      : _M_real(__r), _M_imag(__i) { }




      template<typename _Up>
        complex(const complex<_Up>& __z)
 : _M_real(__z.real()), _M_imag(__z.imag()) { }
# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
      _Tp& real()
      { return _M_real; }


      const _Tp& real() const
      { return _M_real; }


      _Tp& imag()
      { return _M_imag; }


      const _Tp& imag() const
      { return _M_imag; }




      void real(_Tp __val)
      { _M_real = __val; }

      void imag(_Tp __val)
      { _M_imag = __val; }


      complex<_Tp>& operator=(const _Tp&);



      complex<_Tp>&
      operator+=(const _Tp& __t)
      {
 _M_real += __t;
 return *this;
      }



      complex<_Tp>&
      operator-=(const _Tp& __t)
      {
 _M_real -= __t;
 return *this;
      }


      complex<_Tp>& operator*=(const _Tp&);

      complex<_Tp>& operator/=(const _Tp&);





      template<typename _Up>
        complex<_Tp>& operator=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator+=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator-=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator*=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator/=(const complex<_Up>&);

      const complex& __rep() const
      { return *this; }

    private:
      _Tp _M_real;
      _Tp _M_imag;
    };

  template<typename _Tp>
    complex<_Tp>&
    complex<_Tp>::operator=(const _Tp& __t)
    {
     _M_real = __t;
     _M_imag = _Tp();
     return *this;
    }


  template<typename _Tp>
    complex<_Tp>&
    complex<_Tp>::operator*=(const _Tp& __t)
    {
      _M_real *= __t;
      _M_imag *= __t;
      return *this;
    }


  template<typename _Tp>
    complex<_Tp>&
    complex<_Tp>::operator/=(const _Tp& __t)
    {
      _M_real /= __t;
      _M_imag /= __t;
      return *this;
    }

  template<typename _Tp>
    template<typename _Up>
    complex<_Tp>&
    complex<_Tp>::operator=(const complex<_Up>& __z)
    {
      _M_real = __z.real();
      _M_imag = __z.imag();
      return *this;
    }


  template<typename _Tp>
    template<typename _Up>
    complex<_Tp>&
    complex<_Tp>::operator+=(const complex<_Up>& __z)
    {
      _M_real += __z.real();
      _M_imag += __z.imag();
      return *this;
    }


  template<typename _Tp>
    template<typename _Up>
    complex<_Tp>&
    complex<_Tp>::operator-=(const complex<_Up>& __z)
    {
      _M_real -= __z.real();
      _M_imag -= __z.imag();
      return *this;
    }



  template<typename _Tp>
    template<typename _Up>
    complex<_Tp>&
    complex<_Tp>::operator*=(const complex<_Up>& __z)
    {
      const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
      _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
      _M_real = __r;
      return *this;
    }



  template<typename _Tp>
    template<typename _Up>
    complex<_Tp>&
    complex<_Tp>::operator/=(const complex<_Up>& __z)
    {
      const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
      const _Tp __n = std::norm(__z);
      _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
      _M_real = __r / __n;
      return *this;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r += __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator+(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r += __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator+(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __y;
      __r += __x;
      return __r;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r -= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator-(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r -= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator-(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r(__x, -__y.imag());
      __r -= __y.real();
      return __r;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r *= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator*(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r *= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator*(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __y;
      __r *= __x;
      return __r;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator/(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator/(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }



  template<typename _Tp>
    inline complex<_Tp>
    operator+(const complex<_Tp>& __x)
    { return __x; }


  template<typename _Tp>
    inline complex<_Tp>
    operator-(const complex<_Tp>& __x)
    { return complex<_Tp>(-__x.real(), -__x.imag()); }



  template<typename _Tp>
    inline bool
    operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __x.real() == __y.real() && __x.imag() == __y.imag(); }

  template<typename _Tp>
    inline bool
    operator==(const complex<_Tp>& __x, const _Tp& __y)
    { return __x.real() == __y && __x.imag() == _Tp(); }

  template<typename _Tp>
    inline bool
    operator==(const _Tp& __x, const complex<_Tp>& __y)
    { return __x == __y.real() && _Tp() == __y.imag(); }




  template<typename _Tp>
    inline bool
    operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __x.real() != __y.real() || __x.imag() != __y.imag(); }

  template<typename _Tp>
    inline bool
    operator!=(const complex<_Tp>& __x, const _Tp& __y)
    { return __x.real() != __y || __x.imag() != _Tp(); }

  template<typename _Tp>
    inline bool
    operator!=(const _Tp& __x, const complex<_Tp>& __y)
    { return __x != __y.real() || _Tp() != __y.imag(); }



  template<typename _Tp, typename _CharT, class _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
    {
      _Tp __re_x, __im_x;
      _CharT __ch;
      __is >> __ch;
      if (__ch == '(')
 {
   __is >> __re_x >> __ch;
   if (__ch == ',')
     {
       __is >> __im_x >> __ch;
       if (__ch == ')')
  __x = complex<_Tp>(__re_x, __im_x);
       else
  __is.setstate(ios_base::failbit);
     }
   else if (__ch == ')')
     __x = __re_x;
   else
     __is.setstate(ios_base::failbit);
 }
      else
 {
   __is.putback(__ch);
   __is >> __re_x;
   __x = __re_x;
 }
      return __is;
    }


  template<typename _Tp, typename _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
    {
      basic_ostringstream<_CharT, _Traits> __s;
      __s.flags(__os.flags());
      __s.imbue(__os.getloc());
      __s.precision(__os.precision());
      __s << '(' << __x.real() << ',' << __x.imag() << ')';
      return __os << __s.str();
    }
# 541 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
  template<typename _Tp>
    inline _Tp&
    real(complex<_Tp>& __z)
    { return __z.real(); }

  template<typename _Tp>
    inline const _Tp&
    real(const complex<_Tp>& __z)
    { return __z.real(); }

  template<typename _Tp>
    inline _Tp&
    imag(complex<_Tp>& __z)
    { return __z.imag(); }

  template<typename _Tp>
    inline const _Tp&
    imag(const complex<_Tp>& __z)
    { return __z.imag(); }



  template<typename _Tp>
    inline _Tp
    __complex_abs(const complex<_Tp>& __z)
    {
      _Tp __x = __z.real();
      _Tp __y = __z.imag();
      const _Tp __s = std::max(abs(__x), abs(__y));
      if (__s == _Tp())
        return __s;
      __x /= __s;
      __y /= __s;
      return __s * sqrt(__x * __x + __y * __y);
    }


  inline float
  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }

  inline double
  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }

  inline long double
  __complex_abs(const __complex__ long double& __z)
  { return __builtin_cabsl(__z); }

  template<typename _Tp>
    inline _Tp
    abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
# 599 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
  template<typename _Tp>
    inline _Tp
    __complex_arg(const complex<_Tp>& __z)
    { return atan2(__z.imag(), __z.real()); }


  inline float
  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }

  inline double
  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }

  inline long double
  __complex_arg(const __complex__ long double& __z)
  { return __builtin_cargl(__z); }

  template<typename _Tp>
    inline _Tp
    arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
# 629 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
  template<bool>
    struct _Norm_helper
    {
      template<typename _Tp>
        static inline _Tp _S_do_it(const complex<_Tp>& __z)
        {
          const _Tp __x = __z.real();
          const _Tp __y = __z.imag();
          return __x * __x + __y * __y;
        }
    };

  template<>
    struct _Norm_helper<true>
    {
      template<typename _Tp>
        static inline _Tp _S_do_it(const complex<_Tp>& __z)
        {
          _Tp __res = std::abs(__z);
          return __res * __res;
        }
    };

  template<typename _Tp>
    inline _Tp
    norm(const complex<_Tp>& __z)
    {
      return _Norm_helper<__is_floating<_Tp>::__value
 && !0>::_S_do_it(__z);
    }

  template<typename _Tp>
    inline complex<_Tp>
    polar(const _Tp& __rho, const _Tp& __theta)
    { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }

  template<typename _Tp>
    inline complex<_Tp>
    conj(const complex<_Tp>& __z)
    { return complex<_Tp>(__z.real(), -__z.imag()); }




  template<typename _Tp>
    inline complex<_Tp>
    __complex_cos(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
    }


  inline __complex__ float
  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }

  inline __complex__ double
  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }

  inline __complex__ long double
  __complex_cos(const __complex__ long double& __z)
  { return __builtin_ccosl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }







  template<typename _Tp>
    inline complex<_Tp>
    __complex_cosh(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
    }


  inline __complex__ float
  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }

  inline __complex__ double
  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }

  inline __complex__ long double
  __complex_cosh(const __complex__ long double& __z)
  { return __builtin_ccoshl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }







  template<typename _Tp>
    inline complex<_Tp>
    __complex_exp(const complex<_Tp>& __z)
    { return std::polar(exp(__z.real()), __z.imag()); }


  inline __complex__ float
  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }

  inline __complex__ double
  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }

  inline __complex__ long double
  __complex_exp(const __complex__ long double& __z)
  { return __builtin_cexpl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
# 760 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
  template<typename _Tp>
    inline complex<_Tp>
    __complex_log(const complex<_Tp>& __z)
    { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }


  inline __complex__ float
  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }

  inline __complex__ double
  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }

  inline __complex__ long double
  __complex_log(const __complex__ long double& __z)
  { return __builtin_clogl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }






  template<typename _Tp>
    inline complex<_Tp>
    log10(const complex<_Tp>& __z)
    { return std::log(__z) / log(_Tp(10.0)); }


  template<typename _Tp>
    inline complex<_Tp>
    __complex_sin(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
    }


  inline __complex__ float
  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }

  inline __complex__ double
  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }

  inline __complex__ long double
  __complex_sin(const __complex__ long double& __z)
  { return __builtin_csinl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }







  template<typename _Tp>
    inline complex<_Tp>
    __complex_sinh(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
    }


  inline __complex__ float
  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }

  inline __complex__ double
  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }

  inline __complex__ long double
  __complex_sinh(const __complex__ long double& __z)
  { return __builtin_csinhl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
# 852 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
  template<typename _Tp>
    complex<_Tp>
    __complex_sqrt(const complex<_Tp>& __z)
    {
      _Tp __x = __z.real();
      _Tp __y = __z.imag();

      if (__x == _Tp())
        {
          _Tp __t = sqrt(abs(__y) / 2);
          return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
        }
      else
        {
          _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
          _Tp __u = __t / 2;
          return __x > _Tp()
            ? complex<_Tp>(__u, __y / __t)
            : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
        }
    }


  inline __complex__ float
  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }

  inline __complex__ double
  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }

  inline __complex__ long double
  __complex_sqrt(const __complex__ long double& __z)
  { return __builtin_csqrtl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
# 896 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
  template<typename _Tp>
    inline complex<_Tp>
    __complex_tan(const complex<_Tp>& __z)
    { return std::sin(__z) / std::cos(__z); }


  inline __complex__ float
  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }

  inline __complex__ double
  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }

  inline __complex__ long double
  __complex_tan(const __complex__ long double& __z)
  { return __builtin_ctanl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
# 924 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
  template<typename _Tp>
    inline complex<_Tp>
    __complex_tanh(const complex<_Tp>& __z)
    { return std::sinh(__z) / std::cosh(__z); }


  inline __complex__ float
  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }

  inline __complex__ double
  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }

  inline __complex__ long double
  __complex_tanh(const __complex__ long double& __z)
  { return __builtin_ctanhl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
# 956 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
  template<typename _Tp>
    inline complex<_Tp>
    pow(const complex<_Tp>& __z, int __n)
    { return std::__pow_helper(__z, __n); }


  template<typename _Tp>
    complex<_Tp>
    pow(const complex<_Tp>& __x, const _Tp& __y)
    {




      if (__x.imag() == _Tp() && __x.real() > _Tp())
        return pow(__x.real(), __y);

      complex<_Tp> __t = std::log(__x);
      return std::polar(exp(__y * __t.real()), __y * __t.imag());
    }

  template<typename _Tp>
    inline complex<_Tp>
    __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }


  inline __complex__ float
  __complex_pow(__complex__ float __x, __complex__ float __y)
  { return __builtin_cpowf(__x, __y); }

  inline __complex__ double
  __complex_pow(__complex__ double __x, __complex__ double __y)
  { return __builtin_cpow(__x, __y); }

  inline __complex__ long double
  __complex_pow(const __complex__ long double& __x,
  const __complex__ long double& __y)
  { return __builtin_cpowl(__x, __y); }

  template<typename _Tp>
    inline complex<_Tp>
    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __complex_pow(__x.__rep(), __y.__rep()); }







  template<typename _Tp>
    inline complex<_Tp>
    pow(const _Tp& __x, const complex<_Tp>& __y)
    {
      return __x > _Tp() ? std::polar(pow(__x, __y.real()),
          __y.imag() * log(__x))
                  : std::pow(complex<_Tp>(__x), __y);
    }



  template<>
    struct complex<float>
    {
      typedef float value_type;
      typedef __complex__ float _ComplexT;

      complex(_ComplexT __z) : _M_value(__z) { }

      complex(float __r = 0.0f, float __i = 0.0f)
      {
 __real__ _M_value = __r;
 __imag__ _M_value = __i;
      }

      explicit complex(const complex<double>&);
      explicit complex(const complex<long double>&);
# 1044 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
      float& real()
      { return __real__ _M_value; }

      const float& real() const
      { return __real__ _M_value; }

      float& imag()
      { return __imag__ _M_value; }

      const float& imag() const
      { return __imag__ _M_value; }




      void real(float __val)
      { __real__ _M_value = __val; }

      void imag(float __val)
      { __imag__ _M_value = __val; }

      complex<float>&
      operator=(float __f)
      {
 __real__ _M_value = __f;
 __imag__ _M_value = 0.0f;
 return *this;
      }

      complex<float>&
      operator+=(float __f)
      {
 __real__ _M_value += __f;
 return *this;
      }

      complex<float>&
      operator-=(float __f)
      {
 __real__ _M_value -= __f;
 return *this;
      }

      complex<float>&
      operator*=(float __f)
      {
 _M_value *= __f;
 return *this;
      }

      complex<float>&
      operator/=(float __f)
      {
 _M_value /= __f;
 return *this;
      }





      template<typename _Tp>
        complex<float>&
        operator=(const complex<_Tp>& __z)
 {
   __real__ _M_value = __z.real();
   __imag__ _M_value = __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<float>&
        operator+=(const complex<_Tp>& __z)
 {
   __real__ _M_value += __z.real();
   __imag__ _M_value += __z.imag();
   return *this;
 }

      template<class _Tp>
        complex<float>&
        operator-=(const complex<_Tp>& __z)
 {
   __real__ _M_value -= __z.real();
   __imag__ _M_value -= __z.imag();
   return *this;
 }

      template<class _Tp>
        complex<float>&
        operator*=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value *= __t;
   return *this;
 }

      template<class _Tp>
        complex<float>&
        operator/=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value /= __t;
   return *this;
 }

      const _ComplexT& __rep() const { return _M_value; }

    private:
      _ComplexT _M_value;
    };



  template<>
    struct complex<double>
    {
      typedef double value_type;
      typedef __complex__ double _ComplexT;

      complex(_ComplexT __z) : _M_value(__z) { }

      complex(double __r = 0.0, double __i = 0.0)
      {
 __real__ _M_value = __r;
 __imag__ _M_value = __i;
      }

      complex(const complex<float>& __z)
      : _M_value(__z.__rep()) { }

      explicit complex(const complex<long double>&);
# 1190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
      double& real()
      { return __real__ _M_value; }

      const double& real() const
      { return __real__ _M_value; }

      double& imag()
      { return __imag__ _M_value; }

      const double& imag() const
      { return __imag__ _M_value; }




      void real(double __val)
      { __real__ _M_value = __val; }

      void imag(double __val)
      { __imag__ _M_value = __val; }

      complex<double>&
      operator=(double __d)
      {
 __real__ _M_value = __d;
 __imag__ _M_value = 0.0;
 return *this;
      }

      complex<double>&
      operator+=(double __d)
      {
 __real__ _M_value += __d;
 return *this;
      }

      complex<double>&
      operator-=(double __d)
      {
 __real__ _M_value -= __d;
 return *this;
      }

      complex<double>&
      operator*=(double __d)
      {
 _M_value *= __d;
 return *this;
      }

      complex<double>&
      operator/=(double __d)
      {
 _M_value /= __d;
 return *this;
      }




      template<typename _Tp>
        complex<double>&
        operator=(const complex<_Tp>& __z)
 {
   __real__ _M_value = __z.real();
   __imag__ _M_value = __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<double>&
        operator+=(const complex<_Tp>& __z)
 {
   __real__ _M_value += __z.real();
   __imag__ _M_value += __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<double>&
        operator-=(const complex<_Tp>& __z)
 {
   __real__ _M_value -= __z.real();
   __imag__ _M_value -= __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<double>&
        operator*=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value *= __t;
   return *this;
 }

      template<typename _Tp>
        complex<double>&
        operator/=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value /= __t;
   return *this;
 }

      const _ComplexT& __rep() const { return _M_value; }

    private:
      _ComplexT _M_value;
    };



  template<>
    struct complex<long double>
    {
      typedef long double value_type;
      typedef __complex__ long double _ComplexT;

      complex(_ComplexT __z) : _M_value(__z) { }

      complex(long double __r = 0.0L, long double __i = 0.0L)
      {
 __real__ _M_value = __r;
 __imag__ _M_value = __i;
      }

      complex(const complex<float>& __z)
      : _M_value(__z.__rep()) { }

      complex(const complex<double>& __z)
      : _M_value(__z.__rep()) { }
# 1336 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
      long double& real()
      { return __real__ _M_value; }

      const long double& real() const
      { return __real__ _M_value; }

      long double& imag()
      { return __imag__ _M_value; }

      const long double& imag() const
      { return __imag__ _M_value; }




      void real(long double __val)
      { __real__ _M_value = __val; }

      void imag(long double __val)
      { __imag__ _M_value = __val; }

      complex<long double>&
      operator=(long double __r)
      {
 __real__ _M_value = __r;
 __imag__ _M_value = 0.0L;
 return *this;
      }

      complex<long double>&
      operator+=(long double __r)
      {
 __real__ _M_value += __r;
 return *this;
      }

      complex<long double>&
      operator-=(long double __r)
      {
 __real__ _M_value -= __r;
 return *this;
      }

      complex<long double>&
      operator*=(long double __r)
      {
 _M_value *= __r;
 return *this;
      }

      complex<long double>&
      operator/=(long double __r)
      {
 _M_value /= __r;
 return *this;
      }




      template<typename _Tp>
        complex<long double>&
        operator=(const complex<_Tp>& __z)
 {
   __real__ _M_value = __z.real();
   __imag__ _M_value = __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<long double>&
 operator+=(const complex<_Tp>& __z)
 {
   __real__ _M_value += __z.real();
   __imag__ _M_value += __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<long double>&
 operator-=(const complex<_Tp>& __z)
 {
   __real__ _M_value -= __z.real();
   __imag__ _M_value -= __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<long double>&
 operator*=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value *= __t;
   return *this;
 }

      template<typename _Tp>
        complex<long double>&
 operator/=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value /= __t;
   return *this;
 }

      const _ComplexT& __rep() const { return _M_value; }

    private:
      _ComplexT _M_value;
    };



  inline
  complex<float>::complex(const complex<double>& __z)
  : _M_value(__z.__rep()) { }

  inline
  complex<float>::complex(const complex<long double>& __z)
  : _M_value(__z.__rep()) { }

  inline
  complex<double>::complex(const complex<long double>& __z)
  : _M_value(__z.__rep()) { }





  extern template istream& operator>>(istream&, complex<float>&);
  extern template ostream& operator<<(ostream&, const complex<float>&);
  extern template istream& operator>>(istream&, complex<double>&);
  extern template ostream& operator<<(ostream&, const complex<double>&);
  extern template istream& operator>>(istream&, complex<long double>&);
  extern template ostream& operator<<(ostream&, const complex<long double>&);


  extern template wistream& operator>>(wistream&, complex<float>&);
  extern template wostream& operator<<(wostream&, const complex<float>&);
  extern template wistream& operator>>(wistream&, complex<double>&);
  extern template wostream& operator<<(wostream&, const complex<double>&);
  extern template wistream& operator>>(wistream&, complex<long double>&);
  extern template wostream& operator<<(wostream&, const complex<long double>&);





}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {


  template<typename _Tp, typename _Up>
    struct __promote_2<std::complex<_Tp>, _Up>
    {
    public:
      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
    };

  template<typename _Tp, typename _Up>
    struct __promote_2<_Tp, std::complex<_Up> >
    {
    public:
      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
    };

  template<typename _Tp, typename _Up>
    struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
    {
    public:
      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
    };

}
# 14 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp" 2
# 22 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp"
namespace boost { namespace python {

namespace converter
{
  template <class T> struct arg_to_python;
  PyObject* do_return_to_python(char);
  PyObject* do_return_to_python(char const*);
  PyObject* do_return_to_python(PyObject*);
  PyObject* do_arg_to_python(PyObject*);
}


template <class T> struct to_python_value;

namespace detail
{


  struct builtin_to_python
  {



      static const bool uses_registry = false;
  };
}
# 113 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp"
template <> struct to_python_value<bool&> : detail::builtin_to_python { inline PyObject* operator()(bool const& x) const { return (::PyBool_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyBool_Type); } }; template <> struct to_python_value<bool const&> : detail::builtin_to_python { inline PyObject* operator()(bool const& x) const { return (::PyBool_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyBool_Type); } }; namespace converter { template <> struct arg_to_python< bool > : handle<> { arg_to_python(bool const& x) : python::handle<>(::PyBool_FromLong(x)) {} }; }





template <> struct to_python_value<signed char&> : detail::builtin_to_python { inline PyObject* operator()(signed char const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<signed char const&> : detail::builtin_to_python { inline PyObject* operator()(signed char const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< signed char > : handle<> { arg_to_python(signed char const& x) : python::handle<>(::PyInt_FromLong(x)) {} }; } template <> struct to_python_value<unsigned char&> : detail::builtin_to_python { inline PyObject* operator()(unsigned char const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<unsigned char const&> : detail::builtin_to_python { inline PyObject* operator()(unsigned char const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< unsigned char > : handle<> { arg_to_python(unsigned char const& x) : python::handle<>(static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)) {} }; }

template <> struct to_python_value<signed short&> : detail::builtin_to_python { inline PyObject* operator()(signed short const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<signed short const&> : detail::builtin_to_python { inline PyObject* operator()(signed short const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< signed short > : handle<> { arg_to_python(signed short const& x) : python::handle<>(::PyInt_FromLong(x)) {} }; } template <> struct to_python_value<unsigned short&> : detail::builtin_to_python { inline PyObject* operator()(unsigned short const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<unsigned short const&> : detail::builtin_to_python { inline PyObject* operator()(unsigned short const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< unsigned short > : handle<> { arg_to_python(unsigned short const& x) : python::handle<>(static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)) {} }; }
template <> struct to_python_value<signed int&> : detail::builtin_to_python { inline PyObject* operator()(signed int const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<signed int const&> : detail::builtin_to_python { inline PyObject* operator()(signed int const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< signed int > : handle<> { arg_to_python(signed int const& x) : python::handle<>(::PyInt_FromLong(x)) {} }; } template <> struct to_python_value<unsigned int&> : detail::builtin_to_python { inline PyObject* operator()(unsigned int const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<unsigned int const&> : detail::builtin_to_python { inline PyObject* operator()(unsigned int const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< unsigned int > : handle<> { arg_to_python(unsigned int const& x) : python::handle<>(static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)) {} }; }
template <> struct to_python_value<signed long&> : detail::builtin_to_python { inline PyObject* operator()(signed long const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<signed long const&> : detail::builtin_to_python { inline PyObject* operator()(signed long const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< signed long > : handle<> { arg_to_python(signed long const& x) : python::handle<>(::PyInt_FromLong(x)) {} }; } template <> struct to_python_value<unsigned long&> : detail::builtin_to_python { inline PyObject* operator()(unsigned long const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<unsigned long const&> : detail::builtin_to_python { inline PyObject* operator()(unsigned long const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< unsigned long > : handle<> { arg_to_python(unsigned long const& x) : python::handle<>(static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)) {} }; }




template <> struct to_python_value<signed long long&> : detail::builtin_to_python { inline PyObject* operator()(signed long long const& x) const { return (::PyLong_FromLongLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyLong_Type); } }; template <> struct to_python_value<signed long long const&> : detail::builtin_to_python { inline PyObject* operator()(signed long long const& x) const { return (::PyLong_FromLongLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyLong_Type); } }; namespace converter { template <> struct arg_to_python< signed long long > : handle<> { arg_to_python(signed long long const& x) : python::handle<>(::PyLong_FromLongLong(x)) {} }; }
template <> struct to_python_value<unsigned long long&> : detail::builtin_to_python { inline PyObject* operator()(unsigned long long const& x) const { return (::PyLong_FromUnsignedLongLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyLong_Type); } }; template <> struct to_python_value<unsigned long long const&> : detail::builtin_to_python { inline PyObject* operator()(unsigned long long const& x) const { return (::PyLong_FromUnsignedLongLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyLong_Type); } }; namespace converter { template <> struct arg_to_python< unsigned long long > : handle<> { arg_to_python(unsigned long long const& x) : python::handle<>(::PyLong_FromUnsignedLongLong(x)) {} }; }
# 139 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp"
template <> struct to_python_value<char&> : detail::builtin_to_python { inline PyObject* operator()(char const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; template <> struct to_python_value<char const&> : detail::builtin_to_python { inline PyObject* operator()(char const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; namespace converter { template <> struct arg_to_python< char > : handle<> { arg_to_python(char const& x) : python::handle<>(converter::do_return_to_python(x)) {} }; }
template <> struct to_python_value<char const*&> : detail::builtin_to_python { inline PyObject* operator()(char const* const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; template <> struct to_python_value<char const* const&> : detail::builtin_to_python { inline PyObject* operator()(char const* const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; namespace converter { template <> struct arg_to_python< char const* > : handle<> { arg_to_python(char const* const& x) : python::handle<>(converter::do_return_to_python(x)) {} }; }
template <> struct to_python_value<std::string&> : detail::builtin_to_python { inline PyObject* operator()(std::string const& x) const { return (::PyString_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size()))); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; template <> struct to_python_value<std::string const&> : detail::builtin_to_python { inline PyObject* operator()(std::string const& x) const { return (::PyString_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size()))); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; namespace converter { template <> struct arg_to_python< std::string > : handle<> { arg_to_python(std::string const& x) : python::handle<>(::PyString_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size()))) {} }; }



template <> struct to_python_value<std::wstring&> : detail::builtin_to_python { inline PyObject* operator()(std::wstring const& x) const { return (::PyUnicodeUCS4_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size()))); } inline PyTypeObject const* get_pytype() const { return (&PyUnicode_Type); } }; template <> struct to_python_value<std::wstring const&> : detail::builtin_to_python { inline PyObject* operator()(std::wstring const& x) const { return (::PyUnicodeUCS4_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size()))); } inline PyTypeObject const* get_pytype() const { return (&PyUnicode_Type); } }; namespace converter { template <> struct arg_to_python< std::wstring > : handle<> { arg_to_python(std::wstring const& x) : python::handle<>(::PyUnicodeUCS4_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size()))) {} }; }

template <> struct to_python_value<float&> : detail::builtin_to_python { inline PyObject* operator()(float const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; template <> struct to_python_value<float const&> : detail::builtin_to_python { inline PyObject* operator()(float const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; namespace converter { template <> struct arg_to_python< float > : handle<> { arg_to_python(float const& x) : python::handle<>(::PyFloat_FromDouble(x)) {} }; }
template <> struct to_python_value<double&> : detail::builtin_to_python { inline PyObject* operator()(double const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; template <> struct to_python_value<double const&> : detail::builtin_to_python { inline PyObject* operator()(double const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; namespace converter { template <> struct arg_to_python< double > : handle<> { arg_to_python(double const& x) : python::handle<>(::PyFloat_FromDouble(x)) {} }; }
template <> struct to_python_value<long double&> : detail::builtin_to_python { inline PyObject* operator()(long double const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; template <> struct to_python_value<long double const&> : detail::builtin_to_python { inline PyObject* operator()(long double const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; namespace converter { template <> struct arg_to_python< long double > : handle<> { arg_to_python(long double const& x) : python::handle<>(::PyFloat_FromDouble(x)) {} }; }
template <> struct to_python_value<PyObject*&> : detail::builtin_to_python { inline PyObject* operator()(PyObject* const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (0); } }; template <> struct to_python_value<PyObject* const&> : detail::builtin_to_python { inline PyObject* operator()(PyObject* const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (0); } };
template <> struct to_python_value<std::complex<float>&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<float> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; template <> struct to_python_value<std::complex<float> const&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<float> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; namespace converter { template <> struct arg_to_python< std::complex<float> > : handle<> { arg_to_python(std::complex<float> const& x) : python::handle<>(::PyComplex_FromDoubles(x.real(), x.imag())) {} }; }
template <> struct to_python_value<std::complex<double>&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<double> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; template <> struct to_python_value<std::complex<double> const&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<double> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; namespace converter { template <> struct arg_to_python< std::complex<double> > : handle<> { arg_to_python(std::complex<double> const& x) : python::handle<>(::PyComplex_FromDoubles(x.real(), x.imag())) {} }; }
template <> struct to_python_value<std::complex<long double>&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<long double> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; template <> struct to_python_value<std::complex<long double> const&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<long double> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; namespace converter { template <> struct arg_to_python< std::complex<long double> > : handle<> { arg_to_python(std::complex<long double> const& x) : python::handle<>(::PyComplex_FromDoubles(x.real(), x.imag())) {} }; }






namespace converter
{

  void initialize_builtin_converters();

}

}}
# 18 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/object/function_handle.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 18 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_trailing_params.hpp" 1
# 19 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_trailing_binary_params.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/to_python_value.hpp" 1
# 17 "/usr/include/boost-1_42/boost/python/to_python_value.hpp"
# 1 "/usr/include/boost-1_42/boost/python/converter/object_manager.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/converter/object_manager.hpp"
# 1 "/usr/include/boost-1_42/boost/python/converter/pyobject_traits.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/converter/pyobject_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/python/converter/pyobject_type.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/converter/pyobject_type.hpp"
namespace boost { namespace python { namespace converter {

 PyObject* checked_downcast_impl(PyObject*, PyTypeObject*);



template <class Object, PyTypeObject* pytype>
struct pyobject_type
{
    static bool check(PyObject* x)
    {
        return ::PyObject_IsInstance(x, (PyObject*)pytype);
    }

    static Object* checked_downcast(PyObject* x)
    {
        return python::downcast<Object>(
            (checked_downcast_impl)(x, pytype)
            );
    }

    static PyTypeObject const* get_pytype() { return pytype; }

};

}}}
# 10 "/usr/include/boost-1_42/boost/python/converter/pyobject_traits.hpp" 2

namespace boost { namespace python { namespace converter {

template <class> struct pyobject_traits;

template <>
struct pyobject_traits<PyObject>
{

    static bool check(PyObject*) { return true; }
    static PyObject* checked_downcast(PyObject* x) { return x; }

    static PyTypeObject const* get_pytype() { return 0; }

};
# 35 "/usr/include/boost-1_42/boost/python/converter/pyobject_traits.hpp"
template <> struct pyobject_traits<PyTypeObject> : pyobject_type<PyTypeObject, &PyType_Type> {};
template <> struct pyobject_traits<PyListObject> : pyobject_type<PyListObject, &PyList_Type> {};

template <> struct pyobject_traits<PyIntObject> : pyobject_type<PyIntObject, &PyInt_Type> {};

template <> struct pyobject_traits<PyLongObject> : pyobject_type<PyLongObject, &PyLong_Type> {};
template <> struct pyobject_traits<PyDictObject> : pyobject_type<PyDictObject, &PyDict_Type> {};
template <> struct pyobject_traits<PyTupleObject> : pyobject_type<PyTupleObject, &PyTuple_Type> {};

}}}
# 11 "/usr/include/boost-1_42/boost/python/converter/object_manager.hpp" 2
# 65 "/usr/include/boost-1_42/boost/python/converter/object_manager.hpp"
namespace boost { namespace python
{
  namespace api
  {
    class object;
  }
}}

namespace boost { namespace python { namespace converter {



template <class T>
struct handle_object_manager_traits
    : pyobject_traits<typename T::element_type>
{
 private:
  typedef pyobject_traits<typename T::element_type> base;

 public:
  static const bool is_specialized = true;



  static null_ok<typename T::element_type>* adopt(PyObject* p)
  {
      return python::allow_null(base::checked_downcast(p));
  }
};

template <class T>
struct default_object_manager_traits
{
    static const bool is_specialized = python::detail::is_borrowed_ptr<T>::value

         ;
};

template <class T>
struct object_manager_traits
    : mpl::if_c<
         is_handle<T>::value
       , handle_object_manager_traits<T>
       , default_object_manager_traits<T>
    >::type
{
};






template <class T>
struct is_object_manager
    : mpl::bool_<object_manager_traits<T>::is_specialized>
{
};


template <class T>
struct is_reference_to_object_manager
    : mpl::false_
{
};

template <class T>
struct is_reference_to_object_manager<T&>
    : is_object_manager<T>
{
};

template <class T>
struct is_reference_to_object_manager<T const&>
    : is_object_manager<T>
{
};

template <class T>
struct is_reference_to_object_manager<T volatile&>
    : is_object_manager<T>
{
};

template <class T>
struct is_reference_to_object_manager<T const volatile&>
    : is_object_manager<T>
{
};
# 228 "/usr/include/boost-1_42/boost/python/converter/object_manager.hpp"
}}}
# 18 "/usr/include/boost-1_42/boost/python/to_python_value.hpp" 2


# 1 "/usr/include/boost-1_42/boost/python/detail/value_is_shared_ptr.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/detail/value_is_xxx.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/detail/value_is_shared_ptr.hpp" 2


namespace boost { namespace python { namespace detail {

template <class X_> struct value_is_shared_ptr { template <class T> struct is_shared_ptr : mpl::false_ { }; template < class T0 > struct is_shared_ptr< shared_ptr< T0 > > : mpl::true_ { }; static const bool value = is_shared_ptr< typename remove_cv< typename remove_reference<X_>::type >::type >::value; typedef mpl::bool_<value> type; };

}}}
# 21 "/usr/include/boost-1_42/boost/python/to_python_value.hpp" 2
# 29 "/usr/include/boost-1_42/boost/python/to_python_value.hpp"
namespace boost { namespace python {

namespace detail
{


template <bool is_const_ref>
struct object_manager_get_pytype
{
   template <class U>
   static PyTypeObject const* get( U& (*)() =0)
   {
      return converter::object_manager_traits<U>::get_pytype();
   }
};

template <>
struct object_manager_get_pytype<true>
{
   template <class U>
   static PyTypeObject const* get( U const& (*)() =0)
   {
      return converter::object_manager_traits<U>::get_pytype();
   }
};



  template <class T>
  struct object_manager_to_python_value
  {
      typedef typename value_arg<T>::type argument_type;

      PyObject* operator()(argument_type) const;

      typedef boost::mpl::bool_<is_handle<T>::value> is_t_handle;
      typedef boost::detail::indirect_traits::is_reference_to_const<T> is_t_const;
      PyTypeObject const* get_pytype() const {
          return get_pytype_aux((is_t_handle*)0);
      }

      inline static PyTypeObject const* get_pytype_aux(mpl::true_*) {return converter::object_manager_traits<T>::get_pytype();}

      inline static PyTypeObject const* get_pytype_aux(mpl::false_* )
      {
          return object_manager_get_pytype<is_t_const::value>::get((T(*)())0);
      }






      static const bool uses_registry = false;
  };


  template <class T>
  struct registry_to_python_value
  {
      typedef typename value_arg<T>::type argument_type;

      PyObject* operator()(argument_type) const;

      PyTypeObject const* get_pytype() const {return converter::registered<T>::converters.to_python_target_type();}





      static const bool uses_registry = true;
  };

  template <class T>
  struct shared_ptr_to_python_value
  {
      typedef typename value_arg<T>::type argument_type;

      PyObject* operator()(argument_type) const;

      PyTypeObject const* get_pytype() const {return get_pytype((boost::type<argument_type>*)0);}




      static const bool uses_registry = false;
  private:

      template <class U>
      PyTypeObject const* get_pytype(boost::type<shared_ptr<U> &> *) const {return converter::registered<U>::converters.to_python_target_type();}
      template <class U>
      PyTypeObject const* get_pytype(boost::type<const shared_ptr<U> &> *) const {return converter::registered<U>::converters.to_python_target_type();}

  };
}

template <class T>
struct to_python_value
    : mpl::if_<
          detail::value_is_shared_ptr<T>
        , detail::shared_ptr_to_python_value<T>
        , typename mpl::if_<
              mpl::or_<
                  converter::is_object_manager<T>
                , converter::is_reference_to_object_manager<T>
              >
            , detail::object_manager_to_python_value<T>
            , detail::registry_to_python_value<T>
          >::type
      >::type
{
};




namespace detail
{
  template <class T>
  inline PyObject* registry_to_python_value<T>::operator()(argument_type x) const
  {
      typedef converter::registered<argument_type> r;




      return converter::registered<argument_type>::converters.to_python(&x);
  }

  template <class T>
  inline PyObject* object_manager_to_python_value<T>::operator()(argument_type x) const
  {
      return python::upcast<PyObject>(
          python::xincref(
              get_managed_object(x, tag))
          );
  }

  template <class T>
  inline PyObject* shared_ptr_to_python_value<T>::operator()(argument_type x) const
  {
      return converter::shared_ptr_to_python(x);
  }
}

}}
# 22 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 2
# 41 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
namespace boost { namespace python { namespace detail {



typedef int void_result_to_python;

template <bool void_return, bool member>
struct invoke_tag_ {};



template <class R, class F>
struct invoke_tag
  : invoke_tag_<
        is_same<R,void>::value
      , is_member_function_pointer<F>::value
    >
{
};



# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F >
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f )
{
    return rc(f( ));
}

template <class RC, class F >
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f )
{
    f( );
    return none();
}

template <class RC, class F, class TC >
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc )
{
    return rc( (tc().*f)() );
}

template <class RC, class F, class TC >
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc )
{
    (tc().*f)();
    return none();
}
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 )
{
    return rc(f( ac0 () ));
}

template <class RC, class F , class AC0>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 )
{
    f( ac0 () );
    return none();
}

template <class RC, class F, class TC , class AC0>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 )
{
    return rc( (tc().*f)( ac0 () ) );
}

template <class RC, class F, class TC , class AC0>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 )
{
    (tc().*f)( ac0 () );
    return none();
}
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 )
{
    return rc(f( ac0 () , ac1 () ));
}

template <class RC, class F , class AC0 , class AC1>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 )
{
    f( ac0 () , ac1 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 )
{
    return rc( (tc().*f)( ac0 () , ac1 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 )
{
    (tc().*f)( ac0 () , ac1 () );
    return none();
}
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 )
{
    return rc(f( ac0 () , ac1 () , ac2 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 )
{
    f( ac0 () , ac1 () , ac2 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () );
    return none();
}
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () );
    return none();
}
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () );
    return none();
}
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () );
    return none();
}
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () );
    return none();
}
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () );
    return none();
}
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () );
    return none();
}
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () );
    return none();
}
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () );
    return none();
}
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () );
    return none();
}
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () );
    return none();
}
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () );
    return none();
}
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13 , class AC14>
inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 , AC14 & ac14 )
{
    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () , ac14 () ));
}

template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13 , class AC14>
inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 , AC14 & ac14 )
{
    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () , ac14 () );
    return none();
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13 , class AC14>
inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 , AC14 & ac14 )
{
    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () , ac14 () ) );
}

template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13 , class AC14>
inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 , AC14 & ac14 )
{
    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () , ac14 () );
    return none();
}
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 64 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 2

}}}
# 17 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/at.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/at.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/at_impl.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/aux_/at_impl.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/begin_end.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/begin_end.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/sequence_tag_fwd.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/sequence_tag_fwd.hpp"
namespace boost { namespace mpl {

struct nested_begin_end_tag;
struct non_sequence_tag;

template< typename Sequence > struct sequence_tag;

}}
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp" 2


# 1 "/usr/include/boost-1_42/boost/mpl/aux_/has_begin.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/has_begin.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_begin { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::begin>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/aux_/traits_lambda_spec.hpp" 1
# 24 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp" 2


namespace boost { namespace mpl {


namespace aux {

template< typename Sequence >
struct begin_type
{
    typedef typename Sequence::begin type;
};
template< typename Sequence >
struct end_type
{
    typedef typename Sequence::end type;
};

}





template< typename Tag >
struct begin_impl
{
    template< typename Sequence > struct apply
    {
        typedef typename eval_if<aux::has_begin<Sequence, true_>,
                                 aux::begin_type<Sequence>, void_>::type type;
    };
};

template< typename Tag >
struct end_impl
{
    template< typename Sequence > struct apply
    {
        typedef typename eval_if<aux::has_begin<Sequence, true_>,
                                 aux::end_type<Sequence>, void_>::type type;
    };
};
# 82 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp"
template<> struct begin_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::begin type; }; };
template<> struct end_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::end type; }; };




template<> struct begin_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
template<> struct end_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
template<> struct begin_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
template<> struct end_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };







}}
# 19 "/usr/include/boost-1_42/boost/mpl/begin_end.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/sequence_tag.hpp" 1
# 26 "/usr/include/boost-1_42/boost/mpl/sequence_tag.hpp"
namespace boost { namespace mpl {
# 78 "/usr/include/boost-1_42/boost/mpl/sequence_tag.hpp"
namespace aux {

template< bool has_tag_, bool has_begin_ >
struct sequence_tag_impl
{


    template< typename Sequence > struct result2_;
};
# 98 "/usr/include/boost-1_42/boost/mpl/sequence_tag.hpp"
template<> struct sequence_tag_impl<true,true> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
template<> struct sequence_tag_impl<true,false> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
template<> struct sequence_tag_impl<false,true> { template< typename Sequence > struct result2_ { typedef nested_begin_end_tag type; }; };
template<> struct sequence_tag_impl<false,false> { template< typename Sequence > struct result2_ { typedef non_sequence_tag type; }; };



}

template<
      typename Sequence = na
    >
struct sequence_tag
    : aux::sequence_tag_impl<
          ::boost::mpl::aux::has_tag<Sequence>::value
        , ::boost::mpl::aux::has_begin<Sequence>::value
        >::template result2_<Sequence>
{
};



template<> struct sequence_tag< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sequence_tag< T1 > { }; }; template< typename Tag > struct lambda< sequence_tag< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sequence_tag< na > result_; typedef sequence_tag< na > type; }; namespace aux { template< typename T1 > struct template_arity< sequence_tag< T1 > > : int_<1> { }; template<> struct template_arity< sequence_tag< na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_42/boost/mpl/begin_end.hpp" 2



namespace boost { namespace mpl {




template<
      typename Sequence = na
    >
struct begin
{
    typedef typename sequence_tag<Sequence>::type tag_;
    typedef typename begin_impl< tag_ >
        ::template apply< Sequence >::type type;

   
};

template<
      typename Sequence = na
    >
struct end
{
    typedef typename sequence_tag<Sequence>::type tag_;
    typedef typename end_impl< tag_ >
        ::template apply< Sequence >::type type;

   
};

template<> struct begin< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : begin< T1 > { }; }; template< typename Tag > struct lambda< begin< na > , Tag , int_<-1> > { typedef false_ is_le; typedef begin< na > result_; typedef begin< na > type; }; namespace aux { template< typename T1 > struct template_arity< begin< T1 > > : int_<1> { }; template<> struct template_arity< begin< na > > : int_<-1> { }; }
template<> struct end< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : end< T1 > { }; }; template< typename Tag > struct lambda< end< na > , Tag , int_<-1> > { typedef false_ is_le; typedef end< na > result_; typedef end< na > type; }; namespace aux { template< typename T1 > struct template_arity< end< T1 > > : int_<1> { }; template<> struct template_arity< end< na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost-1_42/boost/mpl/aux_/at_impl.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/advance.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/less.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/less.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 1
# 27 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 2







# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/less.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/less.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct less_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct less_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct less_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct less_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct less_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct less

    : less_impl<
          typename less_tag<N1>::type
        , typename less_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   

};

template<> struct less< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : less< T1 , T2 > { }; }; template< typename Tag > struct lambda< less< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef less< na , na > result_; typedef less< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< less< T1 , T2 > > : int_<2> { }; template<> struct template_arity< less< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {

template<>
struct less_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N2::value > N1::value ) >
    {
    };
};

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 36 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 2
# 20 "/usr/include/boost-1_42/boost/mpl/less.hpp" 2
# 19 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/negate.hpp" 1
# 25 "/usr/include/boost-1_42/boost/mpl/negate.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct negate_impl;

template< typename T > struct negate_tag
{
    typedef typename T::tag type;
};

template<
      typename N = na
    >
struct negate

    : negate_impl<
          typename negate_tag<N>::type
        >::template apply<N>::type






{
   
};

template<> struct negate< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : negate< T1 > { }; }; template< typename Tag > struct lambda< negate< na > , Tag , int_<-1> > { typedef false_ is_le; typedef negate< na > result_; typedef negate< na > type; }; namespace aux { template< typename T1 > struct template_arity< negate< T1 > > : int_<1> { }; template<> struct template_arity< negate< na > > : int_<-1> { }; }
# 65 "/usr/include/boost-1_42/boost/mpl/negate.hpp"
template<>
struct negate_impl<integral_c_tag>
{




    template< typename N > struct apply
        : integral_c< typename N::value_type, (-N::value) >

    {
    };
};

}}
# 20 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 2



# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 24 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/advance_forward.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/advance_forward.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 24 "/usr/include/boost-1_42/boost/mpl/aux_/advance_forward.hpp" 2
# 32 "/usr/include/boost-1_42/boost/mpl/aux_/advance_forward.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp"
namespace boost { namespace mpl { namespace aux {

template< long N > struct advance_forward;
template<>
struct advance_forward<0>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef iter0 type;
    };
};

template<>
struct advance_forward<1>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename next<iter0>::type iter1;
        typedef iter1 type;
    };
};

template<>
struct advance_forward<2>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename next<iter0>::type iter1;
        typedef typename next<iter1>::type iter2;
        typedef iter2 type;
    };
};

template<>
struct advance_forward<3>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename next<iter0>::type iter1;
        typedef typename next<iter1>::type iter2;
        typedef typename next<iter2>::type iter3;
        typedef iter3 type;
    };
};

template<>
struct advance_forward<4>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename next<iter0>::type iter1;
        typedef typename next<iter1>::type iter2;
        typedef typename next<iter2>::type iter3;
        typedef typename next<iter3>::type iter4;
        typedef iter4 type;
    };
};

template< long N >
struct advance_forward
{
    template< typename Iterator > struct apply
    {
        typedef typename apply_wrap1<
              advance_forward<4>
            , Iterator
            >::type chunk_result_;

        typedef typename apply_wrap1<
              advance_forward<(
                (N - 4) < 0
                    ? 0
                    : N - 4
                    )>
            , chunk_result_
            >::type type;
    };
};

}}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 33 "/usr/include/boost-1_42/boost/mpl/aux_/advance_forward.hpp" 2
# 25 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/advance_backward.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/advance_backward.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 24 "/usr/include/boost-1_42/boost/mpl/aux_/advance_backward.hpp" 2
# 32 "/usr/include/boost-1_42/boost/mpl/aux_/advance_backward.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp"
namespace boost { namespace mpl { namespace aux {

template< long N > struct advance_backward;
template<>
struct advance_backward<0>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef iter0 type;
    };
};

template<>
struct advance_backward<1>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename prior<iter0>::type iter1;
        typedef iter1 type;
    };
};

template<>
struct advance_backward<2>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename prior<iter0>::type iter1;
        typedef typename prior<iter1>::type iter2;
        typedef iter2 type;
    };
};

template<>
struct advance_backward<3>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename prior<iter0>::type iter1;
        typedef typename prior<iter1>::type iter2;
        typedef typename prior<iter2>::type iter3;
        typedef iter3 type;
    };
};

template<>
struct advance_backward<4>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename prior<iter0>::type iter1;
        typedef typename prior<iter1>::type iter2;
        typedef typename prior<iter2>::type iter3;
        typedef typename prior<iter3>::type iter4;
        typedef iter4 type;
    };
};

template< long N >
struct advance_backward
{
    template< typename Iterator > struct apply
    {
        typedef typename apply_wrap1<
              advance_backward<4>
            , Iterator
            >::type chunk_result_;

        typedef typename apply_wrap1<
              advance_backward<(
                (N - 4) < 0
                    ? 0
                    : N - 4
                    )>
            , chunk_result_
            >::type type;
    };
};

}}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 33 "/usr/include/boost-1_42/boost/mpl/aux_/advance_backward.hpp" 2
# 26 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 2




namespace boost { namespace mpl {


template< typename Tag >
struct advance_impl
{
    template< typename Iterator, typename N > struct apply
    {
        typedef typename less< N,long_<0> >::type backward_;
        typedef typename if_< backward_, negate<N>, N >::type offset_;

        typedef typename if_<
              backward_
            , aux::advance_backward< offset_::value >
            , aux::advance_forward< offset_::value >
            >::type f_;

        typedef typename apply_wrap1<f_,Iterator>::type type;
    };
};


template<
      typename Iterator = na
    , typename N = na
    >
struct advance
    : advance_impl< typename tag<Iterator>::type >
        ::template apply<Iterator,N>
{
};

template<
      typename Iterator
    , long N
    >
struct advance_c
    : advance_impl< typename tag<Iterator>::type >
        ::template apply<Iterator,long_<N> >
{
};

template<> struct advance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : advance< T1 , T2 > { }; }; template< typename Tag > struct lambda< advance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef advance< na , na > result_; typedef advance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< advance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< advance< na , na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/at_impl.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/deref.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/deref.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_type.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_type.hpp"
namespace boost { namespace mpl { namespace aux {
# 48 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_type.hpp"
template< typename T > struct msvc_type
{
    typedef typename T::type type;
};

template<> struct msvc_type<int>
{
    typedef int type;
};



}}}
# 18 "/usr/include/boost-1_42/boost/mpl/deref.hpp" 2




namespace boost { namespace mpl {

template<
      typename Iterator = na
    >
struct deref
{

    typedef typename Iterator::type type;



   
};

template<> struct deref< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : deref< T1 > { }; }; template< typename Tag > struct lambda< deref< na > , Tag , int_<-1> > { typedef false_ is_le; typedef deref< na > result_; typedef deref< na > type; }; namespace aux { template< typename T1 > struct template_arity< deref< T1 > > : int_<1> { }; template<> struct template_arity< deref< na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/at_impl.hpp" 2


namespace boost { namespace mpl {




template< typename Tag >
struct at_impl
{
    template< typename Sequence, typename N > struct apply
    {
        typedef typename advance<
              typename begin<Sequence>::type
            , N
            >::type iter_;

        typedef typename deref<iter_>::type type;
    };
};

 template<> struct at_impl<non_sequence_tag> {};

}}
# 19 "/usr/include/boost-1_42/boost/mpl/at.hpp" 2






namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename N = na
    >
struct at
    : at_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,N >
{
   
};

template<
      typename Sequence
    , long N
    >
struct at_c
    : at_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,mpl::long_<N> >
{
};

template<> struct at< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : at< T1 , T2 > { }; }; template< typename Tag > struct lambda< at< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef at< na , na > result_; typedef at< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< at< T1 , T2 > > : int_<2> { }; template<> struct template_arity< at< na , na > > : int_<-1> { }; }

}}
# 21 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/size.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/size.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/size_impl.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/size_impl.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/distance.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/distance.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/iter_fold.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/iter_fold.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/O1_size.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/O1_size.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/has_size.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/has_size.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_size { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::size>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 21 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp" 2





namespace boost { namespace mpl {
# 35 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp"
namespace aux {
template< typename Sequence > struct O1_size_impl
    : Sequence::size
{
};
}

template< typename Tag >
struct O1_size_impl
{
    template< typename Sequence > struct apply

        : if_<
              aux::has_size<Sequence>
            , aux::O1_size_impl<Sequence>
            , long_<-1>
            >::type
    {
# 69 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp"
    };
};
# 85 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp"
}}
# 20 "/usr/include/boost-1_42/boost/mpl/O1_size.hpp" 2



namespace boost { namespace mpl {


template<
      typename Sequence = na
    >
struct O1_size
    : O1_size_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct O1_size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : O1_size< T1 > { }; }; template< typename Tag > struct lambda< O1_size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef O1_size< na > result_; typedef O1_size< na > type; }; namespace aux { template< typename T1 > struct template_arity< O1_size< T1 > > : int_<1> { }; template<> struct template_arity< O1_size< na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_42/boost/mpl/iter_fold.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/aux_/iter_fold_impl.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/aux_/iter_fold_impl.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/iter_fold_impl.hpp" 2
# 33 "/usr/include/boost-1_42/boost/mpl/aux_/iter_fold_impl.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp"
namespace boost { namespace mpl { namespace aux {



template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl;

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 0,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef state0 state;
    typedef iter0 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 1,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;


    typedef state1 state;
    typedef iter1 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 2,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
    typedef typename mpl::next<iter1>::type iter2;


    typedef state2 state;
    typedef iter2 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 3,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
    typedef typename mpl::next<iter2>::type iter3;


    typedef state3 state;
    typedef iter3 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 4,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
    typedef typename mpl::next<iter2>::type iter3;
    typedef typename apply2< ForwardOp,state3,iter3 >::type state4;
    typedef typename mpl::next<iter3>::type iter4;


    typedef state4 state;
    typedef iter4 iterator;
};

template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl
{
    typedef iter_fold_impl<
          4
        , First
        , Last
        , State
        , ForwardOp
        > chunk_;

    typedef iter_fold_impl<
          ( (N - 4) < 0 ? 0 : N - 4 )
        , typename chunk_::iterator
        , Last
        , typename chunk_::state
        , ForwardOp
        > res_;

    typedef typename res_::state state;
    typedef typename res_::iterator iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< -1,First,Last,State,ForwardOp >
    : iter_fold_impl<
          -1
        , typename mpl::next<First>::type
        , Last
        , typename apply2< ForwardOp,State,First >::type
        , ForwardOp
        >
{
};

template<
      typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< -1,Last,Last,State,ForwardOp >
{
    typedef State state;
    typedef Last iterator;
};

}}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 34 "/usr/include/boost-1_42/boost/mpl/aux_/iter_fold_impl.hpp" 2
# 22 "/usr/include/boost-1_42/boost/mpl/iter_fold.hpp" 2



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename State = na
    , typename ForwardOp = na
    >
struct iter_fold
{
    typedef typename aux::iter_fold_impl<
          ::boost::mpl::O1_size<Sequence>::value
        , typename begin<Sequence>::type
        , typename end<Sequence>::type
        , State
        , typename lambda<ForwardOp>::type
        >::state type;

   
};

template<> struct iter_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : iter_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< iter_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iter_fold< na , na , na > result_; typedef iter_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< iter_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< iter_fold< na , na , na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost-1_42/boost/mpl/distance.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/iterator_range.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/iterator_range.hpp"
namespace boost { namespace mpl {

struct iterator_range_tag;

template<
      typename First = na
    , typename Last = na
    >
struct iterator_range
{
    typedef iterator_range_tag tag;
    typedef iterator_range type;
    typedef First begin;
    typedef Last end;

   
};

template<> struct iterator_range< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : iterator_range< T1 , T2 > { }; }; template< typename Tag > struct lambda< iterator_range< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iterator_range< na , na > result_; typedef iterator_range< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< iterator_range< T1 , T2 > > : int_<2> { }; template<> struct template_arity< iterator_range< na , na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_42/boost/mpl/distance.hpp" 2



# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 24 "/usr/include/boost-1_42/boost/mpl/distance.hpp" 2







namespace boost { namespace mpl {


template< typename Tag > struct distance_impl
{
    template< typename First, typename Last > struct apply

        : aux::msvc_eti_base< typename iter_fold<
              iterator_range<First,Last>
            , mpl::long_<0>
            , next<>
            >::type >
    {
# 60 "/usr/include/boost-1_42/boost/mpl/distance.hpp"
    };
};

template<
      typename First = na
    , typename Last = na
    >
struct distance
    : distance_impl< typename tag<First>::type >
        ::template apply<First, Last>
{
   
};

template<> struct distance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : distance< T1 , T2 > { }; }; template< typename Tag > struct lambda< distance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef distance< na , na > result_; typedef distance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< distance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< distance< na , na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/size_impl.hpp" 2



namespace boost { namespace mpl {




template< typename Tag >
struct size_impl
{
    template< typename Sequence > struct apply

        : distance<
              typename begin<Sequence>::type
            , typename end<Sequence>::type
            >
    {







    };
};

 template<> struct size_impl<non_sequence_tag> {};

}}
# 20 "/usr/include/boost-1_42/boost/mpl/size.hpp" 2




namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct size
    : aux::msvc_eti_base<
        typename size_impl< typename sequence_tag<Sequence>::type >
            ::template apply< Sequence >::type
      >::type
{
   
};

template<> struct size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : size< T1 > { }; }; template< typename Tag > struct lambda< size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef size< na > result_; typedef size< na > type; }; namespace aux { template< typename T1 > struct template_arity< size< T1 > > : int_<1> { }; template<> struct template_arity< size< na > > : int_<-1> { }; }

}}
# 22 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2

namespace boost { namespace python { namespace detail {

struct signature_element
{
    char const* basename;
    converter::pytype_function pytype_f;
    bool lvalue;
};

struct py_func_sig_info
{
    signature_element const *signature;
    signature_element const *ret;
};

template <unsigned> struct signature_arity;



# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<0>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[0 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<1>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[1 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<2>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[2 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<3>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[3 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<4>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[4 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<5>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[5 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<6>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[6 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<7>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[7 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },


        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<8>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[8 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },


        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },


        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<9>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[9 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },


        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },


        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },


        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<10>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[10 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },


        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },


        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },


        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },


        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<11>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[11 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },


        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },


        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },


        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },


        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },


        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<12>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[12 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },


        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },


        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },


        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },


        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },


        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },


        { type_id<typename mpl::at_c<Sig,12>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,12>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,12>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<13>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[13 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },


        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },


        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },


        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },


        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },


        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },


        { type_id<typename mpl::at_c<Sig,12>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,12>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,12>::type>::value },


        { type_id<typename mpl::at_c<Sig,13>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,13>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,13>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<14>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[14 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },


        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },


        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },


        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },


        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },


        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },


        { type_id<typename mpl::at_c<Sig,12>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,12>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,12>::type>::value },


        { type_id<typename mpl::at_c<Sig,13>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,13>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,13>::type>::value },


        { type_id<typename mpl::at_c<Sig,14>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,14>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,14>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<15>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[15 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },


        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },


        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },


        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },


        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },


        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },


        { type_id<typename mpl::at_c<Sig,12>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,12>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,12>::type>::value },


        { type_id<typename mpl::at_c<Sig,13>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,13>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,13>::type>::value },


        { type_id<typename mpl::at_c<Sig,14>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,14>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,14>::type>::value },


        { type_id<typename mpl::at_c<Sig,15>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,15>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,15>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
template <>
struct signature_arity<16>
{
    template <class Sig>
    struct impl
    {
        static signature_element const* elements()
        {
            static signature_element const result[16 +2] = {
# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },


        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },


        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },


        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },


        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },


        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },


        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },


        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },


        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },


        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },


        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },


        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },


        { type_id<typename mpl::at_c<Sig,12>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,12>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,12>::type>::value },


        { type_id<typename mpl::at_c<Sig,13>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,13>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,13>::type>::value },


        { type_id<typename mpl::at_c<Sig,14>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,14>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,14>::type>::value },


        { type_id<typename mpl::at_c<Sig,15>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,15>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,15>::type>::value },


        { type_id<typename mpl::at_c<Sig,16>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,16>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,16>::type>::value },
# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
                {0,0,0}
            };
            return result;
        }
    };
};
# 128 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 43 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2





template <class Sig>
struct signature_base_select
{
    enum { arity = mpl::size<Sig>::value - 1 };
    typedef typename signature_arity<arity>::template impl<Sig> type;
};

template <class Sig>
struct signature
    : signature_base_select<Sig>::type
{
};

}}}
# 18 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2


# 1 "/usr/include/boost-1_42/boost/python/arg_from_python.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/arg_from_python.hpp"
# 1 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp"
# 1 "/usr/include/boost-1_42/boost/python/converter/from_python.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/converter/from_python.hpp"
namespace boost { namespace python { namespace converter {

struct registration;


 void* get_lvalue_from_python(
    PyObject* source, registration const&);

 bool implicit_rvalue_convertible_from_python(
    PyObject* source, registration const&);

 rvalue_from_python_stage1_data rvalue_from_python_stage1(
    PyObject* source, registration const&);

 void* rvalue_from_python_stage2(
    PyObject* source, rvalue_from_python_stage1_data&, registration const&);

 void* rvalue_result_from_python(
    PyObject*, rvalue_from_python_stage1_data&);

 void* reference_result_from_python(PyObject*, registration const&);
 void* pointer_result_from_python(PyObject*, registration const&);

 void void_result_from_python(PyObject*);

 void throw_no_pointer_from_python(PyObject*, registration const&);
 void throw_no_reference_from_python(PyObject*, registration const&);

}}}
# 10 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp" 2
# 23 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/void_ptr.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/detail/void_ptr.hpp"
namespace boost { namespace python { namespace detail {

template <class U>
inline U& void_ptr_to_reference(void const volatile* p, U&(*)())
{
    return *(U*)p;
}

template <class T>
inline void write_void_ptr(void const volatile* storage, void* ptr, T*)
{
    *(T**)storage = (T*)ptr;
}


template <class U>
inline void write_void_ptr_reference(void const volatile* storage, void* ptr, U&(*)())
{

    typedef typename remove_cv<U>::type u_stripped;
    write_void_ptr(storage, ptr, u_stripped(0));
}

}}}
# 24 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/back_reference.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/back_reference.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object_fwd.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/object_fwd.hpp"
namespace boost { namespace python {
namespace api
{
  class object;
}
using api::object;
}}
# 11 "/usr/include/boost-1_42/boost/python/back_reference.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/dependent.hpp" 1







namespace boost { namespace python { namespace detail {
# 19 "/usr/include/boost-1_42/boost/python/detail/dependent.hpp"
template <class T, class U>
struct dependent
{
    typedef T type;
};

}}}
# 12 "/usr/include/boost-1_42/boost/python/back_reference.hpp" 2


namespace boost { namespace python {

template <class T>
struct back_reference
{
 private:
    typedef typename detail::dependent<object,T>::type source_t;
 public:
    typedef T type;

    back_reference(PyObject*, T);
    source_t const& source() const;
    T get() const;
 private:
    source_t m_source;
    T m_value;
};


template<typename T>
class is_back_reference
{
 public:
    static const bool value = false;
};

template<typename T>
class is_back_reference<back_reference<T> >
{
 public:
    static const bool value = true;
};
# 81 "/usr/include/boost-1_42/boost/python/back_reference.hpp"
template <class T>
back_reference<T>::back_reference(PyObject* p, T x)
    : m_source(detail::borrowed_reference(p))
      , m_value(x)
{
}

template <class T>
typename back_reference<T>::source_t const& back_reference<T>::source() const
{
    return m_source;
}

template <class T>
T back_reference<T>::get() const
{
    return m_value;
}

}}
# 25 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/converter/obj_mgr_arg_from_python.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/converter/obj_mgr_arg_from_python.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/construct.hpp" 1







namespace boost { namespace python { namespace detail {

template <class T, class Arg>
void construct_pointee(void* storage, Arg& x

                       , T const volatile*



    )
{
    new (storage) T(x);
}

template <class T, class Arg>
void construct_referent_impl(void* storage, Arg& x, T&(*)())
{
    construct_pointee(storage, x, (T*)0);
}

template <class T, class Arg>
void construct_referent(void* storage, Arg const& x, T(*tag)() = 0)
{
    construct_referent_impl(storage, x, tag);
}

template <class T, class Arg>
void construct_referent(void* storage, Arg& x, T(*tag)() = 0)
{
    construct_referent_impl(storage, x, tag);
}

}}}
# 12 "/usr/include/boost-1_42/boost/python/converter/obj_mgr_arg_from_python.hpp" 2
# 20 "/usr/include/boost-1_42/boost/python/converter/obj_mgr_arg_from_python.hpp"
namespace boost { namespace python { namespace converter {

template <class T>
struct object_manager_value_arg_from_python
{
    typedef T result_type;

    object_manager_value_arg_from_python(PyObject*);
    bool convertible() const;
    T operator()() const;
 private:
    PyObject* m_source;
};
# 43 "/usr/include/boost-1_42/boost/python/converter/obj_mgr_arg_from_python.hpp"
template <class Ref>
struct object_manager_ref_arg_from_python
{
    typedef Ref result_type;

    object_manager_ref_arg_from_python(PyObject*);
    bool convertible() const;
    Ref operator()() const;
    ~object_manager_ref_arg_from_python();
 private:
    typename python::detail::referent_storage<Ref>::type m_result;
};





template <class T>
inline object_manager_value_arg_from_python<T>::object_manager_value_arg_from_python(PyObject* x)
    : m_source(x)
{
}

template <class T>
inline bool object_manager_value_arg_from_python<T>::convertible() const
{
    return object_manager_traits<T>::check(m_source);
}

template <class T>
inline T object_manager_value_arg_from_python<T>::operator()() const
{
    return T(python::detail::borrowed_reference(m_source));
}

template <class Ref>
inline object_manager_ref_arg_from_python<Ref>::object_manager_ref_arg_from_python(PyObject* x)
{





    python::detail::construct_referent<Ref>(&m_result.bytes, (python::detail::borrowed_reference)x);

}

template <class Ref>
inline object_manager_ref_arg_from_python<Ref>::~object_manager_ref_arg_from_python()
{
    python::detail::destroy_referent<Ref>(this->m_result.bytes);
}

namespace detail
{
  template <class T>
  inline bool object_manager_ref_check(T const& x)
  {
      return object_manager_traits<T>::check(get_managed_object(x, tag));
  }
}

template <class Ref>
inline bool object_manager_ref_arg_from_python<Ref>::convertible() const
{
    return detail::object_manager_ref_check(
        python::detail::void_ptr_to_reference(this->m_result.bytes, (Ref(*)())0));
}

template <class Ref>
inline Ref object_manager_ref_arg_from_python<Ref>::operator()() const
{
    return python::detail::void_ptr_to_reference(
        this->m_result.bytes, (Ref(*)())0);
}

}}}
# 27 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp" 2

namespace boost { namespace python
{
  template <class T> struct arg_from_python;
}}




namespace boost { namespace python { namespace converter {
# 45 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp"
template <class T>
struct pointer_cref_arg_from_python
{
    typedef T result_type;

    pointer_cref_arg_from_python(PyObject*);
    T operator()() const;
    bool convertible() const;

 private:


    typename python::detail::referent_storage<T>::type m_result;
};


struct arg_lvalue_from_python_base
{
 public:
    arg_lvalue_from_python_base(void* result);
    bool convertible() const;

 protected:
    void*const& result() const;

 private:
    void* m_result;
};


template <class T>
struct pointer_arg_from_python : arg_lvalue_from_python_base
{
    typedef T result_type;

    pointer_arg_from_python(PyObject*);
    T operator()() const;
};


template <class T>
struct reference_arg_from_python : arg_lvalue_from_python_base
{
    typedef T result_type;

    reference_arg_from_python(PyObject*);
    T operator()() const;
};
# 106 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp"
template <class T>
struct arg_rvalue_from_python
{
    typedef typename boost::add_reference<
        T


    >::type result_type;

    arg_rvalue_from_python(PyObject*);
    bool convertible() const;


    typename arg_rvalue_from_python<T>::

    result_type operator()();

 private:
    rvalue_from_python_data<result_type> m_data;
    PyObject* m_source;
};






template <class T>
struct back_reference_arg_from_python
    : boost::python::arg_from_python<typename T::type>
{
    typedef T result_type;

    back_reference_arg_from_python(PyObject*);
    T operator()();
 private:
    typedef boost::python::arg_from_python<typename T::type> base;
    PyObject* m_source;
};




template <class C, class T, class F>
struct if_2
{
    typedef typename mpl::eval_if<C, mpl::identity<T>, F>::type type;
};



template <class T>
struct select_arg_from_python
{
    typedef typename if_2<
        is_object_manager<T>
      , object_manager_value_arg_from_python<T>
      , if_2<
            is_reference_to_object_manager<T>
          , object_manager_ref_arg_from_python<T>
          , if_2<
                is_pointer<T>
              , pointer_arg_from_python<T>
              , if_2<
                    mpl::and_<
                        indirect_traits::is_reference_to_pointer<T>
                      , indirect_traits::is_reference_to_const<T>
                      , mpl::not_<indirect_traits::is_reference_to_volatile<T> >
                        >
                  , pointer_cref_arg_from_python<T>
                  , if_2<
                        mpl::or_<
                            indirect_traits::is_reference_to_non_const<T>
                          , indirect_traits::is_reference_to_volatile<T>
                        >
                      , reference_arg_from_python<T>
                      , mpl::if_<
                            boost::python::is_back_reference<T>
                          , back_reference_arg_from_python<T>
                          , arg_rvalue_from_python<T>
                        >
                    >
                >
            >
        >
    >::type type;
};
# 202 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp"
inline arg_lvalue_from_python_base::arg_lvalue_from_python_base(void* result)
    : m_result(result)
{
}

inline bool arg_lvalue_from_python_base::convertible() const
{
    return m_result != 0;
}

inline void*const& arg_lvalue_from_python_base::result() const
{
    return m_result;
}



namespace detail
{



  template <class T>
  struct null_ptr_owner
  {
      static T value;
  };
  template <class T> T null_ptr_owner<T>::value = 0;

  template <class U>
  inline U& null_ptr_reference(U&(*)())
  {
      return null_ptr_owner<U>::value;
  }
}

template <class T>
inline pointer_cref_arg_from_python<T>::pointer_cref_arg_from_python(PyObject* p)
{



    python::detail::write_void_ptr_reference(
        m_result.bytes
        , p == (&_Py_NoneStruct) ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters)
        , (T(*)())0);
}

template <class T>
inline bool pointer_cref_arg_from_python<T>::convertible() const
{
    return python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0;
}
template <class T>
inline T pointer_cref_arg_from_python<T>::operator()() const
{
    return (*(void**)m_result.bytes == (&_Py_NoneStruct))
        ? detail::null_ptr_reference((T(*)())0)

        : python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
}



template <class T>
inline pointer_arg_from_python<T>::pointer_arg_from_python(PyObject* p)
    : arg_lvalue_from_python_base(
        p == (&_Py_NoneStruct) ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters))
{
}

template <class T>
inline T pointer_arg_from_python<T>::operator()() const
{
    return (result() == (&_Py_NoneStruct)) ? 0 : T(result());
}



template <class T>
inline reference_arg_from_python<T>::reference_arg_from_python(PyObject* p)
    : arg_lvalue_from_python_base(converter::get_lvalue_from_python(p,registered<T>::converters))
{
}

template <class T>
inline T reference_arg_from_python<T>::operator()() const
{
    return python::detail::void_ptr_to_reference(result(), (T(*)())0);
}




template <class T>
inline arg_rvalue_from_python<T>::arg_rvalue_from_python(PyObject* obj)
    : m_data(converter::rvalue_from_python_stage1(obj, registered<T>::converters))
    , m_source(obj)
{
}

template <class T>
inline bool arg_rvalue_from_python<T>::convertible() const
{
    return m_data.stage1.convertible != 0;
}

template <class T>
inline typename arg_rvalue_from_python<T>::result_type
arg_rvalue_from_python<T>::operator()()
{
    if (m_data.stage1.construct != 0)
        m_data.stage1.construct(m_source, &m_data.stage1);

    return python::detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
}



template <class T>
back_reference_arg_from_python<T>::back_reference_arg_from_python(PyObject* x)
  : base(x), m_source(x)
{
}

template <class T>
inline T
back_reference_arg_from_python<T>::operator()()
{
    return T(m_source, base::operator()());
}

}}}
# 10 "/usr/include/boost-1_42/boost/python/arg_from_python.hpp" 2





namespace boost { namespace python {

template <class T>
struct arg_from_python
    : converter::select_arg_from_python<




          T

      >::type
{
    typedef typename converter::select_arg_from_python<




          T

        >::type base;

    arg_from_python(PyObject*);
};


template <>
struct arg_from_python<PyObject*>
{
    typedef PyObject* result_type;

    arg_from_python(PyObject* p) : m_source(p) {}
    bool convertible() const { return true; }
    PyObject* operator()() const { return m_source; }
 private:
    PyObject* m_source;
};

template <>
struct arg_from_python<PyObject* const&>
{
    typedef PyObject* const& result_type;

    arg_from_python(PyObject* p) : m_source(p) {}
    bool convertible() const { return true; }
    PyObject*const& operator()() const { return m_source; }
 private:
    PyObject* m_source;
};




template <class T>
inline arg_from_python<T>::arg_from_python(PyObject* source)
    : base(source)
{
}

}}
# 21 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/converter/context_result_converter.hpp" 1







namespace boost { namespace python { namespace converter {




struct context_result_converter {};

}}}
# 22 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2




# 1 "/usr/include/boost-1_42/boost/preprocessor/dec.hpp" 1
# 27 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
# 1 "/usr/include/boost-1_42/boost/preprocessor/if.hpp" 1
# 28 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2




# 1 "/usr/include/boost-1_42/boost/compressed_pair.hpp" 1
# 21 "/usr/include/boost-1_42/boost/compressed_pair.hpp"
# 1 "/usr/include/boost-1_42/boost/detail/compressed_pair.hpp" 1
# 28 "/usr/include/boost-1_42/boost/detail/compressed_pair.hpp"
# 1 "/usr/include/boost-1_42/boost/call_traits.hpp" 1
# 21 "/usr/include/boost-1_42/boost/call_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/detail/call_traits.hpp" 1
# 24 "/usr/include/boost-1_42/boost/detail/call_traits.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 25 "/usr/include/boost-1_42/boost/detail/call_traits.hpp" 2





namespace boost{

namespace detail{

template <typename T, bool small_>
struct ct_imp2
{
   typedef const T& param_type;
};

template <typename T>
struct ct_imp2<T, true>
{
   typedef const T param_type;
};

template <typename T, bool isp, bool b1>
struct ct_imp
{
   typedef const T& param_type;
};

template <typename T, bool isp>
struct ct_imp<T, isp, true>
{
   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
};

template <typename T, bool b1>
struct ct_imp<T, true, b1>
{
   typedef const T param_type;
};

}

template <typename T>
struct call_traits
{
public:
   typedef T value_type;
   typedef T& reference;
   typedef const T& const_reference;






   typedef typename boost::detail::ct_imp<
      T,
      ::boost::is_pointer<T>::value,
      ::boost::is_arithmetic<T>::value
   >::param_type param_type;
};

template <typename T>
struct call_traits<T&>
{
   typedef T& value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef T& param_type;
};
# 135 "/usr/include/boost-1_42/boost/detail/call_traits.hpp"
template <typename T, std::size_t BOOST_PP_ITERATION_0>
struct call_traits<T [BOOST_PP_ITERATION_0]>
{
private:
   typedef T array_type[BOOST_PP_ITERATION_0];
public:

   typedef const T* value_type;
   typedef array_type& reference;
   typedef const array_type& const_reference;
   typedef const T* const param_type;
};

template <typename T, std::size_t BOOST_PP_ITERATION_0>
struct call_traits<const T [BOOST_PP_ITERATION_0]>
{
private:
   typedef const T array_type[BOOST_PP_ITERATION_0];
public:

   typedef const T* value_type;
   typedef array_type& reference;
   typedef const array_type& const_reference;
   typedef const T* const param_type;
};


}
# 22 "/usr/include/boost-1_42/boost/call_traits.hpp" 2
# 29 "/usr/include/boost-1_42/boost/detail/compressed_pair.hpp" 2





namespace boost
{

template <class T1, class T2>
class compressed_pair;




namespace details
{

   template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
   struct compressed_pair_switch;

   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, false, false, false>
      {static const int value = 0;};

   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, false, true, true>
      {static const int value = 3;};

   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, false, true, false>
      {static const int value = 1;};

   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, false, false, true>
      {static const int value = 2;};

   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, true, true, true>
      {static const int value = 4;};

   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, true, false, false>
      {static const int value = 5;};

   template <class T1, class T2, int Version> class compressed_pair_imp;



   using std::swap;






   template <typename T>
   inline void cp_swap(T& t1, T& t2)
   {



      swap(t1, t2);
   }



   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 0>
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;

      compressed_pair_imp() {}

      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_(x), second_(y) {}

      compressed_pair_imp(first_param_type x)
         : first_(x) {}

      compressed_pair_imp(second_param_type y)
         : second_(y) {}

      first_reference first() {return first_;}
      first_const_reference first() const {return first_;}

      second_reference second() {return second_;}
      second_const_reference second() const {return second_;}

      void swap(::boost::compressed_pair<T1, T2>& y)
      {
         cp_swap(first_, y.first());
         cp_swap(second_, y.second());
      }
   private:
      first_type first_;
      second_type second_;
   };



   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 1>
      : protected ::boost::remove_cv<T1>::type
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;

      compressed_pair_imp() {}

      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_type(x), second_(y) {}

      compressed_pair_imp(first_param_type x)
         : first_type(x) {}

      compressed_pair_imp(second_param_type y)
         : second_(y) {}

      first_reference first() {return *this;}
      first_const_reference first() const {return *this;}

      second_reference second() {return second_;}
      second_const_reference second() const {return second_;}

      void swap(::boost::compressed_pair<T1,T2>& y)
      {

         cp_swap(second_, y.second());
      }
   private:
      second_type second_;
   };



   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 2>
      : protected ::boost::remove_cv<T2>::type
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;

      compressed_pair_imp() {}

      compressed_pair_imp(first_param_type x, second_param_type y)
         : second_type(y), first_(x) {}

      compressed_pair_imp(first_param_type x)
         : first_(x) {}

      compressed_pair_imp(second_param_type y)
         : second_type(y) {}

      first_reference first() {return first_;}
      first_const_reference first() const {return first_;}

      second_reference second() {return *this;}
      second_const_reference second() const {return *this;}

      void swap(::boost::compressed_pair<T1,T2>& y)
      {

         cp_swap(first_, y.first());
      }

   private:
      first_type first_;
   };



   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 3>
      : protected ::boost::remove_cv<T1>::type,
        protected ::boost::remove_cv<T2>::type
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;

      compressed_pair_imp() {}

      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_type(x), second_type(y) {}

      compressed_pair_imp(first_param_type x)
         : first_type(x) {}

      compressed_pair_imp(second_param_type y)
         : second_type(y) {}

      first_reference first() {return *this;}
      first_const_reference first() const {return *this;}

      second_reference second() {return *this;}
      second_const_reference second() const {return *this;}


      void swap(::boost::compressed_pair<T1,T2>&) {}
   };
# 265 "/usr/include/boost-1_42/boost/detail/compressed_pair.hpp"
   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 4>
      : protected ::boost::remove_cv<T1>::type
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;

      compressed_pair_imp() {}

      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_type(x), m_second(y) {}

      compressed_pair_imp(first_param_type x)
         : first_type(x), m_second(x) {}

      first_reference first() {return *this;}
      first_const_reference first() const {return *this;}

      second_reference second() {return m_second;}
      second_const_reference second() const {return m_second;}

      void swap(::boost::compressed_pair<T1,T2>&) {}
   private:
      T2 m_second;
   };



   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 5>
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;

      compressed_pair_imp() {}

      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_(x), second_(y) {}

      compressed_pair_imp(first_param_type x)
         : first_(x), second_(x) {}

      first_reference first() {return first_;}
      first_const_reference first() const {return first_;}

      second_reference second() {return second_;}
      second_const_reference second() const {return second_;}

      void swap(::boost::compressed_pair<T1, T2>& y)
      {
         cp_swap(first_, y.first());
         cp_swap(second_, y.second());
      }
   private:
      first_type first_;
      second_type second_;
   };

}

template <class T1, class T2>
class compressed_pair
   : private ::boost::details::compressed_pair_imp<T1, T2,
             ::boost::details::compressed_pair_switch<
                    T1,
                    T2,
                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
                    ::boost::is_empty<T1>::value,
                    ::boost::is_empty<T2>::value>::value>
{
private:
   typedef details::compressed_pair_imp<T1, T2,
             ::boost::details::compressed_pair_switch<
                    T1,
                    T2,
                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
                    ::boost::is_empty<T1>::value,
                    ::boost::is_empty<T2>::value>::value> base;
public:
   typedef T1 first_type;
   typedef T2 second_type;
   typedef typename call_traits<first_type>::param_type first_param_type;
   typedef typename call_traits<second_type>::param_type second_param_type;
   typedef typename call_traits<first_type>::reference first_reference;
   typedef typename call_traits<second_type>::reference second_reference;
   typedef typename call_traits<first_type>::const_reference first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;

            compressed_pair() : base() {}
            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
   explicit compressed_pair(first_param_type x) : base(x) {}
   explicit compressed_pair(second_param_type y) : base(y) {}

   first_reference first() {return base::first();}
   first_const_reference first() const {return base::first();}

   second_reference second() {return base::second();}
   second_const_reference second() const {return base::second();}

   void swap(compressed_pair& y) { base::swap(y); }
};




template <class T>
class compressed_pair<T, T>
   : private details::compressed_pair_imp<T, T,
             ::boost::details::compressed_pair_switch<
                    T,
                    T,
                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
                    ::boost::is_empty<T>::value,
                    ::boost::is_empty<T>::value>::value>
{
private:
   typedef details::compressed_pair_imp<T, T,
             ::boost::details::compressed_pair_switch<
                    T,
                    T,
                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
                    ::boost::is_empty<T>::value,
                    ::boost::is_empty<T>::value>::value> base;
public:
   typedef T first_type;
   typedef T second_type;
   typedef typename call_traits<first_type>::param_type first_param_type;
   typedef typename call_traits<second_type>::param_type second_param_type;
   typedef typename call_traits<first_type>::reference first_reference;
   typedef typename call_traits<second_type>::reference second_reference;
   typedef typename call_traits<first_type>::const_reference first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;

            compressed_pair() : base() {}
            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}

   explicit

      compressed_pair(first_param_type x) : base(x) {}

   first_reference first() {return base::first();}
   first_const_reference first() const {return base::first();}

   second_reference second() {return base::second();}
   second_const_reference second() const {return base::second();}

   void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
};

template <class T1, class T2>
inline
void
swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
{
   x.swap(y);
}

}
# 22 "/usr/include/boost-1_42/boost/compressed_pair.hpp" 2
# 33 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2




# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
# 38 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2







namespace boost { namespace python { namespace detail {

template <int BOOST_PP_ITERATION_0>
inline PyObject* get(mpl::int_<BOOST_PP_ITERATION_0>, PyObject* const& args_)
{
    return (((PyTupleObject *)(args_))->ob_item[BOOST_PP_ITERATION_0]);
}

inline unsigned arity(PyObject* const& args_)
{
    return (((PyVarObject*)(args_))->ob_size);
}




typedef int void_result_to_python;




template <class Policies, class Result>
struct select_result_converter
  : mpl::eval_if<
        is_same<Result,void>
      , mpl::identity<void_result_to_python>
      , mpl::apply1<typename Policies::result_converter,Result>
    >
{
};

template <class ArgPackage, class ResultConverter>
inline ResultConverter create_result_converter(
    ArgPackage const& args_
  , ResultConverter*
  , converter::context_result_converter*
)
{
    return ResultConverter(args_);
}

template <class ArgPackage, class ResultConverter>
inline ResultConverter create_result_converter(
    ArgPackage const&
  , ResultConverter*
  , ...
)
{
    return ResultConverter();
}


template <class ResultConverter>
struct converter_target_type
{
    static PyTypeObject const *get_pytype()
    {
        return create_result_converter((PyObject*)0, (ResultConverter *)0, (ResultConverter *)0).get_pytype();
    }
};

template < >
struct converter_target_type <void_result_to_python >
{
    static PyTypeObject const *get_pytype()
    {
        return 0;
    }
};



template <unsigned> struct caller_arity;

template <class F, class CallPolicies, class Sig>
struct caller;
# 134 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<0>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);
# 215 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
               
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 0; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<1>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 1; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<2>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 2; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<3>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 3; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<4>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 4; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<5>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 5; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<6>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 6; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<7>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;


        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5 , c6
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 7; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<8>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;


        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;


        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 8; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<9>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;


        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;


        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;


        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 9; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<10>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;


        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;


        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;


        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;


        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 10; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<11>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;


        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;


        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;


        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;


        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;


        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 11; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<12>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;


        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;


        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;


        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;


        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;


        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;


        typedef typename mpl::next< arg_iter10 >::type arg_iter11; typedef arg_from_python<typename arg_iter11::type> c_t11; c_t11 c11(get(mpl::int_<11>(), inner_args)); if (!c11.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 , c11
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 12; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<13>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;


        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;


        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;


        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;


        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;


        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;


        typedef typename mpl::next< arg_iter10 >::type arg_iter11; typedef arg_from_python<typename arg_iter11::type> c_t11; c_t11 c11(get(mpl::int_<11>(), inner_args)); if (!c11.convertible()) return 0;


        typedef typename mpl::next< arg_iter11 >::type arg_iter12; typedef arg_from_python<typename arg_iter12::type> c_t12; c_t12 c12(get(mpl::int_<12>(), inner_args)); if (!c12.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 , c11 , c12
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 13; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<14>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;


        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;


        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;


        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;


        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;


        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;


        typedef typename mpl::next< arg_iter10 >::type arg_iter11; typedef arg_from_python<typename arg_iter11::type> c_t11; c_t11 c11(get(mpl::int_<11>(), inner_args)); if (!c11.convertible()) return 0;


        typedef typename mpl::next< arg_iter11 >::type arg_iter12; typedef arg_from_python<typename arg_iter12::type> c_t12; c_t12 c12(get(mpl::int_<12>(), inner_args)); if (!c12.convertible()) return 0;


        typedef typename mpl::next< arg_iter12 >::type arg_iter13; typedef arg_from_python<typename arg_iter13::type> c_t13; c_t13 c13(get(mpl::int_<13>(), inner_args)); if (!c13.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 , c11 , c12 , c13
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 14; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<15>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;


        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;


        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;


        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;


        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;


        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;


        typedef typename mpl::next< arg_iter10 >::type arg_iter11; typedef arg_from_python<typename arg_iter11::type> c_t11; c_t11 c11(get(mpl::int_<11>(), inner_args)); if (!c11.convertible()) return 0;


        typedef typename mpl::next< arg_iter11 >::type arg_iter12; typedef arg_from_python<typename arg_iter12::type> c_t12; c_t12 c12(get(mpl::int_<12>(), inner_args)); if (!c12.convertible()) return 0;


        typedef typename mpl::next< arg_iter12 >::type arg_iter13; typedef arg_from_python<typename arg_iter13::type> c_t13; c_t13 c13(get(mpl::int_<13>(), inner_args)); if (!c13.convertible()) return 0;


        typedef typename mpl::next< arg_iter13 >::type arg_iter14; typedef arg_from_python<typename arg_iter14::type> c_t14; c_t14 c14(get(mpl::int_<14>(), inner_args)); if (!c14.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 , c11 , c12 , c13 , c14
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 15; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <>
struct caller_arity<16>
{
    template <class F, class Policies, class Sig>
    struct impl
    {
        impl(F f, Policies p) : m_data(f,p) {}

        PyObject* operator()(PyObject* args_, PyObject*)



        {
            typedef typename mpl::begin<Sig>::type first;
            typedef typename first::type result_t;
            typedef typename select_result_converter<Policies, result_t>::type result_converter;
            typedef typename Policies::argument_package argument_package;

            argument_package inner_args(args_);




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;


        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;


        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;


        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;


        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;


        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;


        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;


        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;


        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;


        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;


        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;


        typedef typename mpl::next< arg_iter10 >::type arg_iter11; typedef arg_from_python<typename arg_iter11::type> c_t11; c_t11 c11(get(mpl::int_<11>(), inner_args)); if (!c11.convertible()) return 0;


        typedef typename mpl::next< arg_iter11 >::type arg_iter12; typedef arg_from_python<typename arg_iter12::type> c_t12; c_t12 c12(get(mpl::int_<12>(), inner_args)); if (!c12.convertible()) return 0;


        typedef typename mpl::next< arg_iter12 >::type arg_iter13; typedef arg_from_python<typename arg_iter13::type> c_t13; c_t13 c13(get(mpl::int_<13>(), inner_args)); if (!c13.convertible()) return 0;


        typedef typename mpl::next< arg_iter13 >::type arg_iter14; typedef arg_from_python<typename arg_iter14::type> c_t14; c_t14 c14(get(mpl::int_<14>(), inner_args)); if (!c14.convertible()) return 0;


        typedef typename mpl::next< arg_iter14 >::type arg_iter15; typedef arg_from_python<typename arg_iter15::type> c_t15; c_t15 c15(get(mpl::int_<15>(), inner_args)); if (!c15.convertible()) return 0;
# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2



            if (!m_data.second().precall(inner_args))
                return 0;

            PyObject* result = detail::invoke(
                detail::invoke_tag<result_t,F>()
              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
              , m_data.first()
                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 , c11 , c12 , c13 , c14 , c15
            );

            return m_data.second().postcall(inner_args, result);
        }

        static unsigned min_arity() { return 16; }

        static py_func_sig_info signature()
        {
            const signature_element * sig = detail::signature<Sig>::elements();


            typedef typename Policies::template extract_return_type<Sig>::type rtype;
            typedef typename select_result_converter<Policies, rtype>::type result_converter;

            static const signature_element ret = {
                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
                , &detail::converter_target_type<result_converter>::get_pytype
                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
            };
            py_func_sig_info res = {sig, &ret };




            return res;
        }
     private:
        compressed_pair<F,Policies> m_data;
    };
};
# 128 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 135 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2






template <class F, class CallPolicies, class Sig>
struct caller_base_select
{
    enum { arity = mpl::size<Sig>::value - 1 };
    typedef typename caller_arity<arity>::template impl<F,CallPolicies,Sig> type;
};
# 166 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
template <class F, class CallPolicies, class Sig>
struct caller
    : caller_base_select<F,CallPolicies,Sig>::type
{
    typedef typename caller_base_select<
        F,CallPolicies,Sig
        >::type base;

    typedef PyObject* result_type;

    caller(F f, CallPolicies p) : base(f,p) {}

};

}}}
# 9 "/usr/include/boost-1_42/boost/python/object/function_handle.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/default_call_policies.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/default_call_policies.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/front.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/front.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/front_impl.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/front_impl.hpp"
namespace boost { namespace mpl {




template< typename Tag >
struct front_impl
{
    template< typename Sequence > struct apply
    {
        typedef typename begin<Sequence>::type iter_;
        typedef typename deref<iter_>::type type;
    };
};

 template<> struct front_impl<non_sequence_tag> {};

}}
# 19 "/usr/include/boost-1_42/boost/mpl/front.hpp" 2




namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct front
    : front_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : front< T1 > { }; }; template< typename Tag > struct lambda< front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef front< na > result_; typedef front< na > type; }; namespace aux { template< typename T1 > struct template_arity< front< T1 > > : int_<1> { }; template<> struct template_arity< front< na > > : int_<-1> { }; }

}}
# 17 "/usr/include/boost-1_42/boost/python/default_call_policies.hpp" 2

namespace boost { namespace python {

template <class T> struct to_python_value;

namespace detail
{

  template <class T> struct specify_a_return_value_policy_to_wrap_functions_returning

  {}

  ;
}

struct default_result_converter;

struct default_call_policies
{


    template <class ArgumentPackage>
    static bool precall(ArgumentPackage const&)
    {
        return true;
    }


    template <class ArgumentPackage>
    static PyObject* postcall(ArgumentPackage const&, PyObject* result)
    {
        return result;
    }

    typedef default_result_converter result_converter;
    typedef PyObject* argument_package;

    template <class Sig>
    struct extract_return_type : mpl::front<Sig>
    {
    };

};

struct default_result_converter
{
    template <class R>
    struct apply
    {
        typedef typename mpl::if_<
            mpl::or_<is_pointer<R>, is_reference<R> >
          , detail::specify_a_return_value_policy_to_wrap_functions_returning<R>
          , boost::python::to_python_value<
                typename detail::value_arg<R>::type
            >
        >::type type;
    };
};


template <>
struct default_result_converter::apply<char const*>
{
    typedef boost::python::to_python_value<char const*const&> type;
};

template <>
struct default_result_converter::apply<PyObject*>
{
    typedef boost::python::to_python_value<PyObject*const&> type;
};

}}
# 10 "/usr/include/boost-1_42/boost/python/object/function_handle.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/py_function.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/object/py_function.hpp" 2




namespace boost { namespace python { namespace objects {






struct py_function_impl_base
{
    virtual ~py_function_impl_base();
    virtual PyObject* operator()(PyObject*, PyObject*) = 0;
    virtual unsigned min_arity() const = 0;
    virtual unsigned max_arity() const;
    virtual python::detail::py_func_sig_info signature() const = 0;
};

template <class Caller>
struct caller_py_function_impl : py_function_impl_base
{
    caller_py_function_impl(Caller const& caller)
        : m_caller(caller)
    {}

    PyObject* operator()(PyObject* args, PyObject* kw)
    {
        return m_caller(args, kw);
    }

    virtual unsigned min_arity() const
    {
        return m_caller.min_arity();
    }

    virtual python::detail::py_func_sig_info signature() const
    {
        return m_caller.signature();
    }

 private:
    Caller m_caller;
};

template <class Caller, class Sig>
struct signature_py_function_impl : py_function_impl_base
{
    signature_py_function_impl(Caller const& caller)
        : m_caller(caller)
    {}

    PyObject* operator()(PyObject* args, PyObject* kw)
    {
        return m_caller(args, kw);
    }

    virtual unsigned min_arity() const
    {
        return mpl::size<Sig>::value - 1;
    }

    virtual python::detail::py_func_sig_info signature() const
    {
        python::detail::signature_element const* sig = python::detail::signature<Sig>::elements();
        python::detail::py_func_sig_info res = {sig, sig};
        return res;
    }

 private:
    Caller m_caller;
};

template <class Caller, class Sig>
struct full_py_function_impl : py_function_impl_base
{
    full_py_function_impl(Caller const& caller, unsigned min_arity, unsigned max_arity)
      : m_caller(caller)
      , m_min_arity(min_arity)
      , m_max_arity(max_arity > min_arity ? max_arity : min_arity)
    {}

    PyObject* operator()(PyObject* args, PyObject* kw)
    {
        return m_caller(args, kw);
    }

    virtual unsigned min_arity() const
    {
        return m_min_arity;
    }

    virtual unsigned max_arity() const
    {
        return m_max_arity;
    }

    virtual python::detail::py_func_sig_info signature() const
    {
        python::detail::signature_element const* sig = python::detail::signature<Sig>::elements();
        python::detail::py_func_sig_info res = {sig, sig};
        return res;
    }

 private:
    Caller m_caller;
    unsigned m_min_arity;
    unsigned m_max_arity;
};

struct py_function
{
    template <class Caller>
    py_function(Caller const& caller)
        : m_impl(new caller_py_function_impl<Caller>(caller))
    {}

    template <class Caller, class Sig>
    py_function(Caller const& caller, Sig)
      : m_impl(new signature_py_function_impl<Caller, Sig>(caller))
    {}

    template <class Caller, class Sig>
    py_function(Caller const& caller, Sig, int min_arity, int max_arity = 0)
      : m_impl(new full_py_function_impl<Caller, Sig>(caller, min_arity, max_arity))
    {}

    py_function(py_function const& rhs)
        : m_impl(rhs.m_impl)
    {}

    PyObject* operator()(PyObject* args, PyObject* kw) const
    {
        return (*m_impl)(args, kw);
    }

    unsigned min_arity() const
    {
        return m_impl->min_arity();
    }

    unsigned max_arity() const
    {
        return m_impl->max_arity();
    }

    python::detail::signature_element const* signature() const
    {
        return m_impl->signature().signature;
    }

    python::detail::signature_element const& get_return_type() const
    {
        return *m_impl->signature().ret;
    }

 private:
    mutable std::auto_ptr<py_function_impl_base> m_impl;
};

}}}
# 11 "/usr/include/boost-1_42/boost/python/object/function_handle.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 37 "/usr/include/boost-1_42/boost/python/signature.hpp"
namespace boost { namespace python { namespace detail {



template <class C1, class C2>
struct most_derived
{
    typedef typename mpl::if_<
        is_convertible<C1*,C2*>
      , C1
      , C2
    >::type type;
};
# 106 "/usr/include/boost-1_42/boost/python/signature.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT >
inline mpl::vector1<
    RT >
get_signature(RT(*)(), void* = 0)
{
    return mpl::vector1<
            RT
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT >
inline mpl::vector2<
    RT, ClassT& >
get_signature(RT(ClassT::*)() )
{
    return mpl::vector2<
            RT, ClassT&
        >();
}

template <
    class Target
  , class RT
  , class ClassT
   
>
inline mpl::vector2<
    RT
  , typename most_derived<Target, ClassT>::type&
   
>
get_signature(
    RT(ClassT::*)()
  , Target*
)
{
    return mpl::vector2<
        RT
      , typename most_derived<Target, ClassT>::type&
       
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT >
inline mpl::vector2<
    RT, ClassT& >
get_signature(RT(ClassT::*)() const)
{
    return mpl::vector2<
            RT, ClassT&
        >();
}

template <
    class Target
  , class RT
  , class ClassT
   
>
inline mpl::vector2<
    RT
  , typename most_derived<Target, ClassT>::type&
   
>
get_signature(
    RT(ClassT::*)() const
  , Target*
)
{
    return mpl::vector2<
        RT
      , typename most_derived<Target, ClassT>::type&
       
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT >
inline mpl::vector2<
    RT, ClassT& >
get_signature(RT(ClassT::*)() volatile)
{
    return mpl::vector2<
            RT, ClassT&
        >();
}

template <
    class Target
  , class RT
  , class ClassT
   
>
inline mpl::vector2<
    RT
  , typename most_derived<Target, ClassT>::type&
   
>
get_signature(
    RT(ClassT::*)() volatile
  , Target*
)
{
    return mpl::vector2<
        RT
      , typename most_derived<Target, ClassT>::type&
       
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT >
inline mpl::vector2<
    RT, ClassT& >
get_signature(RT(ClassT::*)() const volatile)
{
    return mpl::vector2<
            RT, ClassT&
        >();
}

template <
    class Target
  , class RT
  , class ClassT
   
>
inline mpl::vector2<
    RT
  , typename most_derived<Target, ClassT>::type&
   
>
get_signature(
    RT(ClassT::*)() const volatile
  , Target*
)
{
    return mpl::vector2<
        RT
      , typename most_derived<Target, ClassT>::type&
       
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0>
inline mpl::vector2<
    RT , T0>
get_signature(RT(*)( T0), void* = 0)
{
    return mpl::vector2<
            RT , T0
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0>
inline mpl::vector3<
    RT, ClassT& , T0>
get_signature(RT(ClassT::*)( T0) )
{
    return mpl::vector3<
            RT, ClassT& , T0
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0
>
inline mpl::vector3<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0
>
get_signature(
    RT(ClassT::*)( T0)
  , Target*
)
{
    return mpl::vector3<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0>
inline mpl::vector3<
    RT, ClassT& , T0>
get_signature(RT(ClassT::*)( T0) const)
{
    return mpl::vector3<
            RT, ClassT& , T0
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0
>
inline mpl::vector3<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0
>
get_signature(
    RT(ClassT::*)( T0) const
  , Target*
)
{
    return mpl::vector3<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0>
inline mpl::vector3<
    RT, ClassT& , T0>
get_signature(RT(ClassT::*)( T0) volatile)
{
    return mpl::vector3<
            RT, ClassT& , T0
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0
>
inline mpl::vector3<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0
>
get_signature(
    RT(ClassT::*)( T0) volatile
  , Target*
)
{
    return mpl::vector3<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0>
inline mpl::vector3<
    RT, ClassT& , T0>
get_signature(RT(ClassT::*)( T0) const volatile)
{
    return mpl::vector3<
            RT, ClassT& , T0
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0
>
inline mpl::vector3<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0
>
get_signature(
    RT(ClassT::*)( T0) const volatile
  , Target*
)
{
    return mpl::vector3<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1>
inline mpl::vector3<
    RT , T0 , T1>
get_signature(RT(*)( T0 , T1), void* = 0)
{
    return mpl::vector3<
            RT , T0 , T1
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1>
inline mpl::vector4<
    RT, ClassT& , T0 , T1>
get_signature(RT(ClassT::*)( T0 , T1) )
{
    return mpl::vector4<
            RT, ClassT& , T0 , T1
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1
>
inline mpl::vector4<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1
>
get_signature(
    RT(ClassT::*)( T0 , T1)
  , Target*
)
{
    return mpl::vector4<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1>
inline mpl::vector4<
    RT, ClassT& , T0 , T1>
get_signature(RT(ClassT::*)( T0 , T1) const)
{
    return mpl::vector4<
            RT, ClassT& , T0 , T1
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1
>
inline mpl::vector4<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1
>
get_signature(
    RT(ClassT::*)( T0 , T1) const
  , Target*
)
{
    return mpl::vector4<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1>
inline mpl::vector4<
    RT, ClassT& , T0 , T1>
get_signature(RT(ClassT::*)( T0 , T1) volatile)
{
    return mpl::vector4<
            RT, ClassT& , T0 , T1
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1
>
inline mpl::vector4<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1
>
get_signature(
    RT(ClassT::*)( T0 , T1) volatile
  , Target*
)
{
    return mpl::vector4<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1>
inline mpl::vector4<
    RT, ClassT& , T0 , T1>
get_signature(RT(ClassT::*)( T0 , T1) const volatile)
{
    return mpl::vector4<
            RT, ClassT& , T0 , T1
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1
>
inline mpl::vector4<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1
>
get_signature(
    RT(ClassT::*)( T0 , T1) const volatile
  , Target*
)
{
    return mpl::vector4<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2>
inline mpl::vector4<
    RT , T0 , T1 , T2>
get_signature(RT(*)( T0 , T1 , T2), void* = 0)
{
    return mpl::vector4<
            RT , T0 , T1 , T2
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2>
inline mpl::vector5<
    RT, ClassT& , T0 , T1 , T2>
get_signature(RT(ClassT::*)( T0 , T1 , T2) )
{
    return mpl::vector5<
            RT, ClassT& , T0 , T1 , T2
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2
>
inline mpl::vector5<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2)
  , Target*
)
{
    return mpl::vector5<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2>
inline mpl::vector5<
    RT, ClassT& , T0 , T1 , T2>
get_signature(RT(ClassT::*)( T0 , T1 , T2) const)
{
    return mpl::vector5<
            RT, ClassT& , T0 , T1 , T2
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2
>
inline mpl::vector5<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2) const
  , Target*
)
{
    return mpl::vector5<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2>
inline mpl::vector5<
    RT, ClassT& , T0 , T1 , T2>
get_signature(RT(ClassT::*)( T0 , T1 , T2) volatile)
{
    return mpl::vector5<
            RT, ClassT& , T0 , T1 , T2
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2
>
inline mpl::vector5<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2) volatile
  , Target*
)
{
    return mpl::vector5<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2>
inline mpl::vector5<
    RT, ClassT& , T0 , T1 , T2>
get_signature(RT(ClassT::*)( T0 , T1 , T2) const volatile)
{
    return mpl::vector5<
            RT, ClassT& , T0 , T1 , T2
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2
>
inline mpl::vector5<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2) const volatile
  , Target*
)
{
    return mpl::vector5<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3>
inline mpl::vector5<
    RT , T0 , T1 , T2 , T3>
get_signature(RT(*)( T0 , T1 , T2 , T3), void* = 0)
{
    return mpl::vector5<
            RT , T0 , T1 , T2 , T3
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3>
inline mpl::vector6<
    RT, ClassT& , T0 , T1 , T2 , T3>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3) )
{
    return mpl::vector6<
            RT, ClassT& , T0 , T1 , T2 , T3
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3
>
inline mpl::vector6<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3)
  , Target*
)
{
    return mpl::vector6<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3>
inline mpl::vector6<
    RT, ClassT& , T0 , T1 , T2 , T3>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3) const)
{
    return mpl::vector6<
            RT, ClassT& , T0 , T1 , T2 , T3
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3
>
inline mpl::vector6<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3) const
  , Target*
)
{
    return mpl::vector6<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3>
inline mpl::vector6<
    RT, ClassT& , T0 , T1 , T2 , T3>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3) volatile)
{
    return mpl::vector6<
            RT, ClassT& , T0 , T1 , T2 , T3
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3
>
inline mpl::vector6<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3) volatile
  , Target*
)
{
    return mpl::vector6<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3>
inline mpl::vector6<
    RT, ClassT& , T0 , T1 , T2 , T3>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3) const volatile)
{
    return mpl::vector6<
            RT, ClassT& , T0 , T1 , T2 , T3
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3
>
inline mpl::vector6<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3) const volatile
  , Target*
)
{
    return mpl::vector6<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4>
inline mpl::vector6<
    RT , T0 , T1 , T2 , T3 , T4>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4), void* = 0)
{
    return mpl::vector6<
            RT , T0 , T1 , T2 , T3 , T4
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4>
inline mpl::vector7<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) )
{
    return mpl::vector7<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4
>
inline mpl::vector7<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4)
  , Target*
)
{
    return mpl::vector7<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4>
inline mpl::vector7<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) const)
{
    return mpl::vector7<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4
>
inline mpl::vector7<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) const
  , Target*
)
{
    return mpl::vector7<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4>
inline mpl::vector7<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) volatile)
{
    return mpl::vector7<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4
>
inline mpl::vector7<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) volatile
  , Target*
)
{
    return mpl::vector7<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4>
inline mpl::vector7<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) const volatile)
{
    return mpl::vector7<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4
>
inline mpl::vector7<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) const volatile
  , Target*
)
{
    return mpl::vector7<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
inline mpl::vector7<
    RT , T0 , T1 , T2 , T3 , T4 , T5>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5), void* = 0)
{
    return mpl::vector7<
            RT , T0 , T1 , T2 , T3 , T4 , T5
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
inline mpl::vector8<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) )
{
    return mpl::vector8<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5
>
inline mpl::vector8<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5)
  , Target*
)
{
    return mpl::vector8<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
inline mpl::vector8<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) const)
{
    return mpl::vector8<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5
>
inline mpl::vector8<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) const
  , Target*
)
{
    return mpl::vector8<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
inline mpl::vector8<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile)
{
    return mpl::vector8<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5
>
inline mpl::vector8<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile
  , Target*
)
{
    return mpl::vector8<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
inline mpl::vector8<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile)
{
    return mpl::vector8<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5
>
inline mpl::vector8<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile
  , Target*
)
{
    return mpl::vector8<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
inline mpl::vector8<
    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6), void* = 0)
{
    return mpl::vector8<
            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
inline mpl::vector9<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) )
{
    return mpl::vector9<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6
>
inline mpl::vector9<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)
  , Target*
)
{
    return mpl::vector9<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
inline mpl::vector9<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const)
{
    return mpl::vector9<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6
>
inline mpl::vector9<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const
  , Target*
)
{
    return mpl::vector9<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
inline mpl::vector9<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile)
{
    return mpl::vector9<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6
>
inline mpl::vector9<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile
  , Target*
)
{
    return mpl::vector9<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
inline mpl::vector9<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile)
{
    return mpl::vector9<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6
>
inline mpl::vector9<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile
  , Target*
)
{
    return mpl::vector9<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
inline mpl::vector9<
    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7), void* = 0)
{
    return mpl::vector9<
            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
inline mpl::vector10<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) )
{
    return mpl::vector10<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7
>
inline mpl::vector10<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)
  , Target*
)
{
    return mpl::vector10<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
inline mpl::vector10<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const)
{
    return mpl::vector10<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7
>
inline mpl::vector10<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const
  , Target*
)
{
    return mpl::vector10<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
inline mpl::vector10<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile)
{
    return mpl::vector10<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7
>
inline mpl::vector10<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile
  , Target*
)
{
    return mpl::vector10<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
inline mpl::vector10<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile)
{
    return mpl::vector10<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7
>
inline mpl::vector10<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile
  , Target*
)
{
    return mpl::vector10<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
inline mpl::vector10<
    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8), void* = 0)
{
    return mpl::vector10<
            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
inline mpl::vector11<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) )
{
    return mpl::vector11<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8
>
inline mpl::vector11<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
  , Target*
)
{
    return mpl::vector11<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
inline mpl::vector11<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const)
{
    return mpl::vector11<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8
>
inline mpl::vector11<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const
  , Target*
)
{
    return mpl::vector11<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
inline mpl::vector11<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile)
{
    return mpl::vector11<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8
>
inline mpl::vector11<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile
  , Target*
)
{
    return mpl::vector11<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
inline mpl::vector11<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile)
{
    return mpl::vector11<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8
>
inline mpl::vector11<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile
  , Target*
)
{
    return mpl::vector11<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
inline mpl::vector11<
    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9), void* = 0)
{
    return mpl::vector11<
            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
inline mpl::vector12<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) )
{
    return mpl::vector12<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9
>
inline mpl::vector12<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
  , Target*
)
{
    return mpl::vector12<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
inline mpl::vector12<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const)
{
    return mpl::vector12<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9
>
inline mpl::vector12<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const
  , Target*
)
{
    return mpl::vector12<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
inline mpl::vector12<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile)
{
    return mpl::vector12<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9
>
inline mpl::vector12<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile
  , Target*
)
{
    return mpl::vector12<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
inline mpl::vector12<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile)
{
    return mpl::vector12<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9
>
inline mpl::vector12<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile
  , Target*
)
{
    return mpl::vector12<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
inline mpl::vector12<
    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10), void* = 0)
{
    return mpl::vector12<
            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
inline mpl::vector13<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) )
{
    return mpl::vector13<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10
>
inline mpl::vector13<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
  , Target*
)
{
    return mpl::vector13<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
inline mpl::vector13<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const)
{
    return mpl::vector13<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10
>
inline mpl::vector13<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const
  , Target*
)
{
    return mpl::vector13<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
inline mpl::vector13<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile)
{
    return mpl::vector13<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10
>
inline mpl::vector13<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile
  , Target*
)
{
    return mpl::vector13<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
inline mpl::vector13<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile)
{
    return mpl::vector13<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10
>
inline mpl::vector13<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile
  , Target*
)
{
    return mpl::vector13<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
inline mpl::vector13<
    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11), void* = 0)
{
    return mpl::vector13<
            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
inline mpl::vector14<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) )
{
    return mpl::vector14<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11
>
inline mpl::vector14<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
  , Target*
)
{
    return mpl::vector14<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
inline mpl::vector14<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const)
{
    return mpl::vector14<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11
>
inline mpl::vector14<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const
  , Target*
)
{
    return mpl::vector14<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
inline mpl::vector14<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile)
{
    return mpl::vector14<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11
>
inline mpl::vector14<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile
  , Target*
)
{
    return mpl::vector14<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
inline mpl::vector14<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile)
{
    return mpl::vector14<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11
>
inline mpl::vector14<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile
  , Target*
)
{
    return mpl::vector14<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
inline mpl::vector14<
    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12), void* = 0)
{
    return mpl::vector14<
            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
inline mpl::vector15<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) )
{
    return mpl::vector15<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12
>
inline mpl::vector15<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
  , Target*
)
{
    return mpl::vector15<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
inline mpl::vector15<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const)
{
    return mpl::vector15<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12
>
inline mpl::vector15<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const
  , Target*
)
{
    return mpl::vector15<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
inline mpl::vector15<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile)
{
    return mpl::vector15<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12
>
inline mpl::vector15<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile
  , Target*
)
{
    return mpl::vector15<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
inline mpl::vector15<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile)
{
    return mpl::vector15<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12
>
inline mpl::vector15<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile
  , Target*
)
{
    return mpl::vector15<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
inline mpl::vector15<
    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13), void* = 0)
{
    return mpl::vector15<
            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
inline mpl::vector16<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) )
{
    return mpl::vector16<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13
>
inline mpl::vector16<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
  , Target*
)
{
    return mpl::vector16<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
inline mpl::vector16<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const)
{
    return mpl::vector16<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13
>
inline mpl::vector16<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const
  , Target*
)
{
    return mpl::vector16<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
inline mpl::vector16<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile)
{
    return mpl::vector16<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13
>
inline mpl::vector16<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile
  , Target*
)
{
    return mpl::vector16<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
inline mpl::vector16<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile)
{
    return mpl::vector16<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13
>
inline mpl::vector16<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile
  , Target*
)
{
    return mpl::vector16<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
inline mpl::vector16<
    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14), void* = 0)
{
    return mpl::vector16<
            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
        >();
}





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
inline mpl::vector17<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) )
{
    return mpl::vector17<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14
>
inline mpl::vector17<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
  , Target*
)
{
    return mpl::vector17<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
    >();
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
inline mpl::vector17<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const)
{
    return mpl::vector17<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14
>
inline mpl::vector17<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const
  , Target*
)
{
    return mpl::vector17<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
    >();
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
inline mpl::vector17<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile)
{
    return mpl::vector17<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14
>
inline mpl::vector17<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile
  , Target*
)
{
    return mpl::vector17<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
    >();
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
template <
    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
inline mpl::vector17<
    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile)
{
    return mpl::vector17<
            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
        >();
}

template <
    class Target
  , class RT
  , class ClassT
    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14
>
inline mpl::vector17<
    RT
  , typename most_derived<Target, ClassT>::type&
    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
>
get_signature(
    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile
  , Target*
)
{
    return mpl::vector17<
        RT
      , typename most_derived<Target, ClassT>::type&
        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
    >();
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 107 "/usr/include/boost-1_42/boost/python/signature.hpp" 2




}}}
# 12 "/usr/include/boost-1_42/boost/python/object/function_handle.hpp" 2

namespace boost { namespace python { namespace objects {

 handle<> function_handle_impl(py_function const& f);




template <class F, class Signature>
inline handle<> function_handle(F const& f, Signature)
{
    enum { n_arguments = mpl::size<Signature>::value - 1 };

    return objects::function_handle_impl(
        python::detail::caller<
            F,default_call_policies,Signature
        >(
            f, default_call_policies()
         )
    );
}



template <class F>
handle<> make_function_handle(F f)
{
    return objects::function_handle(f, python::detail::get_signature(f));
}

}}}
# 20 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2





# 1 "/usr/include/boost-1_42/boost/python/detail/string_literal.hpp" 1







# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 9 "/usr/include/boost-1_42/boost/python/detail/string_literal.hpp" 2

# 1 "/usr/include/boost-1_42/boost/type_traits/array_traits.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/detail/string_literal.hpp" 2




namespace boost { namespace python { namespace detail {


template <class T>
struct is_string_literal : mpl::false_
{
};


template <std::size_t n>
struct is_string_literal<char const[n]> : mpl::true_
{
};
# 86 "/usr/include/boost-1_42/boost/python/detail/string_literal.hpp"
}}}
# 26 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2




# 1 "/usr/include/boost-1_42/boost/type_traits/function_traits.hpp" 1
# 16 "/usr/include/boost-1_42/boost/type_traits/function_traits.hpp"
namespace boost {


namespace detail {

template<typename Function> struct function_traits_helper;

template<typename R>
struct function_traits_helper<R (*)(void)>
{
  static const unsigned arity = 0;
  typedef R result_type;
};

template<typename R, typename T1>
struct function_traits_helper<R (*)(T1)>
{
  static const unsigned arity = 1;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T1 argument_type;
};

template<typename R, typename T1, typename T2>
struct function_traits_helper<R (*)(T1, T2)>
{
  static const unsigned arity = 2;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T1 first_argument_type;
  typedef T2 second_argument_type;
};

template<typename R, typename T1, typename T2, typename T3>
struct function_traits_helper<R (*)(T1, T2, T3)>
{
  static const unsigned arity = 3;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4>
struct function_traits_helper<R (*)(T1, T2, T3, T4)>
{
  static const unsigned arity = 4;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
{
  static const unsigned arity = 5;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
{
  static const unsigned arity = 6;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
{
  static const unsigned arity = 7;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
{
  static const unsigned arity = 8;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
  static const unsigned arity = 9;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
  typedef T9 arg9_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9,
         typename T10>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
  static const unsigned arity = 10;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
  typedef T9 arg9_type;
  typedef T10 arg10_type;
};

}

template<typename Function>
struct function_traits :
   public detail::function_traits_helper<typename boost::add_pointer<Function>::type>
{
};
# 234 "/usr/include/boost-1_42/boost/type_traits/function_traits.hpp"
}
# 31 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2




namespace boost { namespace python { namespace converter {

template <class T> struct is_object_manager;

namespace detail
{
  template <class T>
  struct function_arg_to_python : handle<>
  {
      function_arg_to_python(T const& x);
  };

  template <class T>
  struct reference_arg_to_python : handle<>
  {
      reference_arg_to_python(T& x);
   private:
      static PyObject* get_object(T& x);
  };

  template <class T>
  struct shared_ptr_arg_to_python : handle<>
  {
      shared_ptr_arg_to_python(T const& x);
   private:
      static PyObject* get_object(T& x);
  };

  template <class T>
  struct value_arg_to_python : arg_to_python_base
  {

      value_arg_to_python(T const&);
  };

  template <class Ptr>
  struct pointer_deep_arg_to_python : arg_to_python_base
  {

      pointer_deep_arg_to_python(Ptr);
  };

  template <class Ptr>
  struct pointer_shallow_arg_to_python : handle<>
  {

      pointer_shallow_arg_to_python(Ptr);
   private:
      static PyObject* get_object(Ptr p);
  };


  template <class T>
  struct object_manager_arg_to_python
  {
      object_manager_arg_to_python(T const& x) : m_src(x) {}

      PyObject* get() const
      {
          return python::upcast<PyObject>(get_managed_object(m_src, tag));
      }

   private:
      T const& m_src;
  };

  template <class T>
  struct select_arg_to_python
  {
      typedef typename unwrap_reference<T>::type unwrapped_referent;
      typedef typename unwrap_pointer<T>::type unwrapped_ptr;

      typedef typename mpl::if_<


          python::detail::is_string_literal<T const>
        , arg_to_python<char const*>

        , typename mpl::if_<
              python::detail::value_is_shared_ptr<T>
            , shared_ptr_arg_to_python<T>

            , typename mpl::if_<
                mpl::or_<
                    is_function<T>
                  , indirect_traits::is_pointer_to_function<T>
                  , is_member_function_pointer<T>
                >
                , function_arg_to_python<T>

                , typename mpl::if_<
                      is_object_manager<T>
                    , object_manager_arg_to_python<T>

                    , typename mpl::if_<
                          is_pointer<T>
                        , pointer_deep_arg_to_python<T>

                        , typename mpl::if_<
                              is_pointer_wrapper<T>
                            , pointer_shallow_arg_to_python<unwrapped_ptr>

                            , typename mpl::if_<
                                  is_reference_wrapper<T>
                                , reference_arg_to_python<unwrapped_referent>
                                , value_arg_to_python<T>
                              >::type
                          >::type
                      >::type
                  >::type
              >::type
          >::type
      >::type

      type;
  };
}

template <class T>
struct arg_to_python
    : detail::select_arg_to_python<T>::type
{
    typedef typename detail::select_arg_to_python<T>::type base;
 public:

    arg_to_python(T const& x);
};




namespace detail
{


  using python::detail::yes_convertible;
  using python::detail::no_convertible;
  using python::detail::unspecialized;

  template <class T> struct cannot_convert_raw_PyObject;

  template <class T, class Convertibility>
  struct reject_raw_object_helper
  {
      static void error(Convertibility)
      {
          cannot_convert_raw_PyObject<T*>::to_python_use_handle_instead();
      }
      static void error(...) {}
  };

  template <class T>
  inline void reject_raw_object_ptr(T*)
  {
      reject_raw_object_helper<T,yes_convertible>::error(
          python::detail::convertible<PyObject const volatile*>::check((T*)0));

      typedef typename remove_cv<T>::type value_type;

      reject_raw_object_helper<T,no_convertible>::error(
          python::detail::convertible<unspecialized*>::check(
              (base_type_traits<value_type>*)0
              ));
  }


  template <class T>
  inline function_arg_to_python<T>::function_arg_to_python(T const& x)
      : handle<>(python::objects::make_function_handle(x))
  {
  }

  template <class T>
  inline value_arg_to_python<T>::value_arg_to_python(T const& x)
      : arg_to_python_base(&x, registered<T>::converters)
  {
  }

  template <class Ptr>
  inline pointer_deep_arg_to_python<Ptr>::pointer_deep_arg_to_python(Ptr x)
      : arg_to_python_base(x, registered_pointee<Ptr>::converters)
  {
      detail::reject_raw_object_ptr((Ptr)0);
  }

  template <class T>
  inline PyObject* reference_arg_to_python<T>::get_object(T& x)
  {
      to_python_indirect<T&,python::detail::make_reference_holder> convert;
      return convert(x);
  }

  template <class T>
  inline reference_arg_to_python<T>::reference_arg_to_python(T& x)
      : handle<>(reference_arg_to_python<T>::get_object(x))
  {
  }

  template <class T>
  inline shared_ptr_arg_to_python<T>::shared_ptr_arg_to_python(T const& x)
      : handle<>(shared_ptr_to_python(x))
  {
  }

  template <class Ptr>
  inline pointer_shallow_arg_to_python<Ptr>::pointer_shallow_arg_to_python(Ptr x)
      : handle<>(pointer_shallow_arg_to_python<Ptr>::get_object(x))
  {
      detail::reject_raw_object_ptr((Ptr)0);
  }

  template <class Ptr>
  inline PyObject* pointer_shallow_arg_to_python<Ptr>::get_object(Ptr x)
  {
      to_python_indirect<Ptr,python::detail::make_reference_holder> convert;
      return convert(x);
  }
}

template <class T>
inline arg_to_python<T>::arg_to_python(T const& x)
    : base(x)
{}

}}}
# 16 "/usr/include/boost-1_42/boost/python/call.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/converter/return_from_python.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/converter/return_from_python.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/void_return.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/detail/void_return.hpp"
namespace boost { namespace python { namespace detail {

struct void_return
{
    void_return() {}
 private:
    void operator=(void_return const&);
};

template <class T>
struct returnable
{
    typedef T type;
};
# 40 "/usr/include/boost-1_42/boost/python/detail/void_return.hpp"
}}}
# 15 "/usr/include/boost-1_42/boost/python/converter/return_from_python.hpp" 2






namespace boost { namespace python { namespace converter {

template <class T> struct is_object_manager;

namespace detail
{
  template <class T>
  struct return_pointer_from_python
  {
      typedef T result_type;
      T operator()(PyObject*) const;
  };

  template <class T>
  struct return_reference_from_python
  {
      typedef T result_type;
      T operator()(PyObject*) const;
  };

  template <class T>
  struct return_rvalue_from_python
  {
      typedef T result_type;

      return_rvalue_from_python();
      result_type operator()(PyObject*);
   private:
      rvalue_from_python_data<T> m_data;
  };

  template <class T>
  struct return_object_manager_from_python
  {
      typedef T result_type;
      result_type operator()(PyObject*) const;
  };

  template <class T>
  struct select_return_from_python
  {
      static const bool obj_mgr = is_object_manager<T>::value
                                                      ;

      static const bool ptr = is_pointer<T>::value
                                           ;

      static const bool ref = is_reference<T>::value
                                             ;

      typedef typename mpl::if_c<
          obj_mgr
          , return_object_manager_from_python<T>
          , typename mpl::if_c<
              ptr
              , return_pointer_from_python<T>
              , typename mpl::if_c<
                  ref
                  , return_reference_from_python<T>
                  , return_rvalue_from_python<T>
                >::type
            >::type
         >::type type;
  };
}

template <class T>
struct return_from_python
    : detail::select_return_from_python<T>::type
{
};


template <>
struct return_from_python<void>
{
    typedef python::detail::returnable<void>::type result_type;

    result_type operator()(PyObject* x) const
    {
        (void_result_from_python)(x);



    }
};




namespace detail
{
  template <class T>
  inline return_rvalue_from_python<T>::return_rvalue_from_python()
      : m_data(
          const_cast<registration*>(&registered<T>::converters)
          )
  {
  }

  template <class T>
  inline typename return_rvalue_from_python<T>::result_type
  return_rvalue_from_python<T>::operator()(PyObject* obj)
  {




    handle<> holder(obj);

      return *(T*)
          (rvalue_result_from_python)(obj, m_data.stage1);
  }

  template <class T>
  inline T return_reference_from_python<T>::operator()(PyObject* obj) const
  {
      return python::detail::void_ptr_to_reference(
          (reference_result_from_python)(obj, registered<T>::converters)
          , (T(*)())0);
  }

  template <class T>
  inline T return_pointer_from_python<T>::operator()(PyObject* obj) const
  {
      return T(
          (pointer_result_from_python)(obj, registered_pointee<T>::converters)
          );
  }

  template <class T>
  inline T return_object_manager_from_python<T>::operator()(PyObject* obj) const
  {
      return T(
          object_manager_traits<T>::adopt(expect_non_null(obj))
          );
  }
}

}}}
# 17 "/usr/include/boost-1_42/boost/python/call.hpp" 2
# 27 "/usr/include/boost-1_42/boost/python/call.hpp"
namespace boost { namespace python {





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
   
    >
typename detail::returnable<R>::type
call(PyObject* callable
   
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" ")")
           
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" ")")
            , converter::arg_to_python<A0>(a0).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 47 "/usr/include/boost-1_42/boost/python/call.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14
    >
typename detail::returnable<R>::type
call(PyObject* callable
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallFunction(
            callable
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get() , converter::arg_to_python<A14>(a14).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 34 "/usr/include/boost-1_42/boost/python/call.hpp" 2



}}
# 13 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2





# 1 "/usr/include/boost-1_42/boost/python/def_visitor.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/def_visitor.hpp"
namespace boost { namespace python {

template <class DerivedVisitor> class def_visitor;
template <class T, class X1, class X2, class X3> class class_;

class def_visitor_access
{






    template <class Derived> friend class def_visitor;



    template <class V, class classT>
    static void visit(V const& v, classT& c)
    {
        v.derived_visitor().visit(c);
    }


    template <class V, class classT, class OptionalArgs>
    static void visit(
        V const& v
      , classT& c
      , char const* name
      , OptionalArgs const& options
    )
    {
        v.derived_visitor().visit(c, name, options);
    }

};


template <class DerivedVisitor>
class def_visitor
{
    friend class def_visitor_access;







    template <class T, class X1, class X2, class X3> friend class class_;



    template <class classT>
    void visit(classT& c) const
    {
        def_visitor_access::visit(*this, c);
    }


    template <class classT, class OptionalArgs>
    void visit(classT& c, char const* name, OptionalArgs const& options) const
    {
        def_visitor_access::visit(*this, c, name, options);
    }

 protected:
    DerivedVisitor const& derived_visitor() const
    {
        return static_cast<DerivedVisitor const&>(*this);
    }
};

}}
# 19 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2





# 1 "/usr/include/boost-1_42/boost/python/object/add_to_namespace.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/object/add_to_namespace.hpp"
namespace boost { namespace python { namespace objects {




 void add_to_namespace(
    object const& name_space, char const* name, object const& attribute);

 void add_to_namespace(
    object const& name_space, char const* name, object const& attribute, char const* doc);

}}}
# 25 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2






# 1 "/usr/include/boost-1_42/boost/python/detail/def_helper_fwd.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/detail/not_specified.hpp" 1







namespace boost { namespace python { namespace detail {

  struct not_specified {};

}}}
# 9 "/usr/include/boost-1_42/boost/python/detail/def_helper_fwd.hpp" 2

namespace boost { namespace python { namespace detail {

template <class T1, class T2 = not_specified, class T3 = not_specified, class T4 = not_specified>
struct def_helper;

}}}
# 32 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2
# 43 "/usr/include/boost-1_42/boost/python/object_core.hpp"
namespace boost { namespace python {

namespace detail
{
  class kwds_proxy;
  class args_proxy;
}

namespace converter
{
  template <class T> struct arg_to_python;
}


namespace api
{





  template <class Policies> class proxy;

  struct const_attribute_policies;
  struct attribute_policies;
  struct const_objattribute_policies;
  struct objattribute_policies;
  struct const_item_policies;
  struct item_policies;
  struct const_slice_policies;
  struct slice_policies;
  class slice_nil;

  typedef proxy<const_attribute_policies> const_object_attribute;
  typedef proxy<attribute_policies> object_attribute;
  typedef proxy<const_objattribute_policies> const_object_objattribute;
  typedef proxy<objattribute_policies> object_objattribute;
  typedef proxy<const_item_policies> const_object_item;
  typedef proxy<item_policies> object_item;
  typedef proxy<const_slice_policies> const_object_slice;
  typedef proxy<slice_policies> object_slice;




  template <class T> struct is_proxy : mpl::false_ { }; template < class T0 > struct is_proxy< boost::python::api::proxy< T0 > > : mpl::true_ { };

  template <class T> struct object_initializer;

  class object;
  typedef PyObject* (object::*bool_type)() const;

  template <class U>
  class object_operators : public def_visitor<U>
  {
   protected:

      typedef object const& object_cref;



   public:


      object operator()() const;


# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 52 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0);
    }
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1);
    }
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2);
    }
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3);
    }
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4);
    }
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5);
    }
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6);
    }
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
    }
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
    }
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
    }
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);
    }
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);
    }
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);
    }
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);
    }
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
    typename detail::dependent<object, A0>::type
    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14) const
    {
        typedef typename detail::dependent<object, A0>::type obj;
        U const& self = *static_cast<U const*>(this);
        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);
    }
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 111 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2

      detail::args_proxy operator* () const;
      object operator()(detail::args_proxy const &args) const;
      object operator()(detail::args_proxy const &args,
                        detail::kwds_proxy const &kwds) const;



      operator bool_type() const;
      bool operator!() const;



      const_object_attribute attr(char const*) const;
      object_attribute attr(char const*);
      const_object_objattribute attr(object const&) const;
      object_objattribute attr(object const&);


      template <class T>
      object contains(T const& key) const;



      const_object_item operator[](object_cref) const;
      object_item operator[](object_cref);

      template <class T>
      const_object_item
      operator[](T const& key) const

          ;






      template <class T>
      object_item
      operator[](T const& key)

          ;
# 162 "/usr/include/boost-1_42/boost/python/object_core.hpp"
      const_object_slice slice(object_cref, object_cref) const;
      object_slice slice(object_cref, object_cref);

      const_object_slice slice(slice_nil, object_cref) const;
      object_slice slice(slice_nil, object_cref);

      const_object_slice slice(object_cref, slice_nil) const;
      object_slice slice(object_cref, slice_nil);

      const_object_slice slice(slice_nil, slice_nil) const;
      object_slice slice(slice_nil, slice_nil);

      template <class T, class V>
      const_object_slice
      slice(T const& start, V const& end) const

          ;
# 187 "/usr/include/boost-1_42/boost/python/object_core.hpp"
      template <class T, class V>
      object_slice
      slice(T const& start, V const& end)

          ;
# 200 "/usr/include/boost-1_42/boost/python/object_core.hpp"
   private:

      template <class ClassT, class DocStringT>
      void visit(ClassT& cl, char const* name, python::detail::def_helper<DocStringT> const& helper) const
      {


          typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_same<char const*,DocStringT>::value || detail::is_string_literal<DocStringT const>::value)) == 0 ? false : true) >)>

 boost_static_assert_typedef_209;

          objects::add_to_namespace(cl, name, this->derived_visitor(), helper.doc());
      }

      friend class python::def_visitor_access;

   private:




    typedef object const& object_cref2;



  };





  struct object_base : object_operators<object>
  {

      inline object_base(object_base const&);
      inline object_base(PyObject* ptr);

      inline object_base& operator=(object_base const& rhs);
      inline ~object_base();


      inline PyObject* ptr() const;

   private:
      PyObject* m_ptr;
  };
# 267 "/usr/include/boost-1_42/boost/python/object_core.hpp"
  template <class T, class U>
  struct is_derived
    : is_convertible<
          typename remove_reference<T>::type*
        , U const*
      >
  {};


  template <class T>
  typename objects::unforward_cref<T>::type do_unforward_cref(T const& x)
  {




      return x;

  }
# 296 "/usr/include/boost-1_42/boost/python/object_core.hpp"
  class object;

  template <class T>
  PyObject* object_base_initializer(T const& x)
  {
      typedef typename is_derived<
          typename objects::unforward_cref<T>::type
        , object
      >::type is_obj;

      return object_initializer<
          typename unwrap_reference<T>::type
      >::get(
            x
          , is_obj()
      );
  }

  class object : public object_base
  {
   public:

      object();


      template <class T>
      explicit object(
          T const& x





      )
        : object_base(object_base_initializer(x))
      {
      }


      explicit object(handle<> const&);
   private:

   public:
      explicit object(detail::borrowed_reference);
      explicit object(detail::new_reference);
      explicit object(detail::new_non_null_reference);
  };
# 376 "/usr/include/boost-1_42/boost/python/object_core.hpp"
  template <bool is_proxy = false, bool is_object_manager = false>
  struct object_initializer_impl
  {
      static PyObject*
      get(object const& x, mpl::true_)
      {
          return python::incref(x.ptr());
      }

      template <class T>
      static PyObject*
      get(T const& x, mpl::false_)
      {
          return python::incref(converter::arg_to_python<T>(x).get());
      }
  };

  template <>
  struct object_initializer_impl<true, false>
  {
      template <class Policies>
      static PyObject*
      get(proxy<Policies> const& x, mpl::false_)
      {
          return python::incref(x.operator object().ptr());
      }
  };

  template <>
  struct object_initializer_impl<false, true>
  {
      template <class T, class U>
      static PyObject*
      get(T const& x, U)
      {
          return python::incref(get_managed_object(x, boost::python::tag));
      }
  };

  template <>
  struct object_initializer_impl<true, true>
  {};

  template <class T>
  struct object_initializer : object_initializer_impl<
      is_proxy<T>::value
    , converter::is_object_manager<T>::value
  >
  {};

}
using api::object;
template <class T> struct extract;





namespace detail
{

class call_proxy
{
public:
  call_proxy(object target) : m_target(target) {}
  operator object() const { return m_target;}

 private:
    object m_target;
};

class kwds_proxy : public call_proxy
{
public:
  kwds_proxy(object o = object()) : call_proxy(o) {}
};
class args_proxy : public call_proxy
{
public:
  args_proxy(object o) : call_proxy(o) {}
  kwds_proxy operator* () const { return kwds_proxy(*this);}
};
}

template <typename U>
detail::args_proxy api::object_operators<U>::operator* () const
{
  object_cref2 x = *static_cast<U const*>(this);
  return boost::python::detail::args_proxy(x);
}

template <typename U>
object api::object_operators<U>::operator()(detail::args_proxy const &args) const
{
  U const& self = *static_cast<U const*>(this);
  PyObject *result = PyObject_Call(get_managed_object(self, boost::python::tag),
                                   args.operator object().ptr(),
                                   0);
  return object(boost::python::detail::new_reference(result));

}

template <typename U>
object api::object_operators<U>::operator()(detail::args_proxy const &args,
                                            detail::kwds_proxy const &kwds) const
{
  U const& self = *static_cast<U const*>(this);
  PyObject *result = PyObject_Call(get_managed_object(self, boost::python::tag),
                                   args.operator object().ptr(),
                                   kwds.operator object().ptr());
  return object(boost::python::detail::new_reference(result));

}


template <typename U>
template <class T>
object api::object_operators<U>::contains(T const& key) const
{
    return this->attr("__contains__")(object(key));
}


inline object::object()
    : object_base(python::incref((&_Py_NoneStruct)))
{}


inline api::object_base::object_base(object_base const& rhs)
    : m_ptr(python::incref(rhs.m_ptr))
{}

inline api::object_base::object_base(PyObject* p)
    : m_ptr(p)
{}

inline api::object_base& api::object_base::operator=(api::object_base const& rhs)
{
    ( ((PyObject*)(rhs.m_ptr))->ob_refcnt++);
    if ( --((PyObject*)(this->m_ptr))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(this->m_ptr)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(this->m_ptr))));
    this->m_ptr = rhs.m_ptr;
    return *this;
}

inline api::object_base::~object_base()
{
    if ( --((PyObject*)(m_ptr))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(m_ptr)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(m_ptr))));
}

inline object::object(detail::borrowed_reference p)
    : object_base(python::incref((PyObject*)p))
{}

inline object::object(detail::new_reference p)
    : object_base(expect_non_null((PyObject*)p))
{}

inline object::object(detail::new_non_null_reference p)
    : object_base((PyObject*)p)
{}

inline PyObject* api::object_base::ptr() const
{
    return m_ptr;
}




namespace converter
{
  template <class T> struct object_manager_traits;

  template <>
  struct object_manager_traits<object>
  {
      static const bool is_specialized = true;
      static bool check(PyObject*) { return true; }

      static python::detail::new_non_null_reference adopt(PyObject* x)
      {
          return python::detail::new_non_null_reference(x);
      }

      static PyTypeObject const *get_pytype() {return 0;}

  };
}

inline PyObject* get_managed_object(object const& x, tag_t)
{
    return x.ptr();
}

}}

# 1 "/usr/include/boost-1_42/boost/python/slice_nil.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/slice_nil.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object_core.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/slice_nil.hpp" 2

namespace boost { namespace python { namespace api {

class slice_nil : public object
{
 public:
    slice_nil() : object() {}
};


static const slice_nil _ = slice_nil();


template <class T>
struct slice_bound
{
    typedef object type;
};

template <>
struct slice_bound<slice_nil>
{
    typedef slice_nil type;
};

}

using api::slice_nil;

using api::_;


}}
# 573 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2
# 26 "/usr/include/boost-1_42/boost/python/args.hpp" 2



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 30 "/usr/include/boost-1_42/boost/python/args.hpp" 2


namespace boost { namespace python {

typedef detail::keywords<1> arg;
typedef arg arg_;

namespace detail
{
  template <std::size_t nkeywords>
  struct keywords_base
  {
      static const std::size_t size = nkeywords;

      keyword_range range() const
      {
          return keyword_range(elements, elements + nkeywords);
      }

      keyword elements[nkeywords];

      keywords<nkeywords+1>
      operator,(python::arg const &k) const;

      keywords<nkeywords + 1>
      operator,(char const *name) const;
  };

  template <std::size_t nkeywords>
  struct keywords : keywords_base<nkeywords>
  {
  };

  template <>
  struct keywords<1> : keywords_base<1>
  {
      explicit keywords(char const *name)
      {
          elements[0].name = name;
      }

      template <class T>
      python::arg& operator=(T const& value)
      {
          object z(value);
          elements[0].default_value = handle<>(python::borrowed(object(value).ptr()));
          return *this;
      }

      operator detail::keyword const&() const
      {
          return elements[0];
      }
  };

  template <std::size_t nkeywords>
  inline
  keywords<nkeywords+1>
  keywords_base<nkeywords>::operator,(python::arg const &k) const
  {
      keywords<nkeywords> const& l = *static_cast<keywords<nkeywords> const*>(this);
      python::detail::keywords<nkeywords+1> res;
      std::copy(l.elements, l.elements+nkeywords, res.elements);
      res.elements[nkeywords] = k.elements[0];
      return res;
  }

  template <std::size_t nkeywords>
  inline
  keywords<nkeywords + 1>
  keywords_base<nkeywords>::operator,(char const *name) const
  {
      return this->operator,(python::arg(name));
  }


  template<typename T>
  struct is_keywords
  {
      static const bool value = false;
  };

  template<std::size_t nkeywords>
  struct is_keywords<keywords<nkeywords> >
  {
      static const bool value = true;
  };
  template <class T>
  struct is_reference_to_keywords
  {
      static const bool is_ref = is_reference<T>::value;
      typedef typename remove_reference<T>::type deref;
      typedef typename remove_cv<deref>::type key_t;
      static const bool is_key = is_keywords<key_t>::value;
      static const bool value = (is_ref & is_key);

      typedef mpl::bool_<value> type;
     
  };
# 154 "/usr/include/boost-1_42/boost/python/args.hpp"
}

inline detail::keywords<1> args(char const* name)
{
    return detail::keywords<1>(name);
}
# 170 "/usr/include/boost-1_42/boost/python/args.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 40 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        inline detail::keywords<2> args( char const* name0 , char const* name1) { detail::keywords<2> result; result.elements[0].name = name0; result.elements[1].name = name1; return result; }


        inline detail::keywords<3> args( char const* name0 , char const* name1 , char const* name2) { detail::keywords<3> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; return result; }


        inline detail::keywords<4> args( char const* name0 , char const* name1 , char const* name2 , char const* name3) { detail::keywords<4> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; return result; }


        inline detail::keywords<5> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4) { detail::keywords<5> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; return result; }


        inline detail::keywords<6> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5) { detail::keywords<6> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; return result; }


        inline detail::keywords<7> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6) { detail::keywords<7> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; return result; }


        inline detail::keywords<8> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7) { detail::keywords<8> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; return result; }


        inline detail::keywords<9> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8) { detail::keywords<9> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; return result; }


        inline detail::keywords<10> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9) { detail::keywords<10> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; return result; }


        inline detail::keywords<11> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9 , char const* name10) { detail::keywords<11> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; result.elements[10].name = name10; return result; }


        inline detail::keywords<12> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9 , char const* name10 , char const* name11) { detail::keywords<12> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; result.elements[10].name = name10; result.elements[11].name = name11; return result; }


        inline detail::keywords<13> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9 , char const* name10 , char const* name11 , char const* name12) { detail::keywords<13> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; result.elements[10].name = name10; result.elements[11].name = name11; result.elements[12].name = name12; return result; }


        inline detail::keywords<14> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9 , char const* name10 , char const* name11 , char const* name12 , char const* name13) { detail::keywords<14> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; result.elements[10].name = name10; result.elements[11].name = name11; result.elements[12].name = name12; result.elements[13].name = name13; return result; }


        inline detail::keywords<15> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9 , char const* name10 , char const* name11 , char const* name12 , char const* name13 , char const* name14) { detail::keywords<15> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; result.elements[10].name = name10; result.elements[11].name = name11; result.elements[12].name = name12; result.elements[13].name = name13; result.elements[14].name = name14; return result; }
# 171 "/usr/include/boost-1_42/boost/python/args.hpp" 2

}}
# 12 "/usr/include/boost-1_42/boost/python.hpp" 2


# 1 "/usr/include/boost-1_42/boost/python/bases.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/bases.hpp"
namespace boost { namespace python {




  template < typename Base0 = mpl::void_ >
  struct bases : detail::type_list< Base0 >::type
  {};

  namespace detail
  {

    template <class T> struct specifies_bases
        : mpl::false_
    {
    };

    template < class Base0 >
    struct specifies_bases< bases< Base0 > >
        : mpl::true_
    {
    };
# 55 "/usr/include/boost-1_42/boost/python/bases.hpp"
    template <class T, class Prev = bases<> >
    struct select_bases
        : mpl::if_<
                specifies_bases<T>
                , T
                , Prev
          >
    {
    };
  }

}}
# 15 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 17 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 26 "/usr/include/boost-1_42/boost/python/call_method.hpp"
namespace boost { namespace python {





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
   
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
   
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" ")")
           
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" ")")
            , converter::arg_to_python<A0>(a0).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"




template <
    class R
    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14
    >
typename detail::returnable<R>::type
call_method(PyObject* self, char const* name
    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14
    , boost::type<R>* = 0
    )
{
    PyObject* const result =
        PyEval_CallMethod(
            self
            , const_cast<char*>(name)
            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get() , converter::arg_to_python<A14>(a14).get()
            );
# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
    converter::return_from_python<R> converter;
    return converter(result);
}
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 33 "/usr/include/boost-1_42/boost/python/call_method.hpp" 2



}}
# 18 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/class.hpp" 1
# 12 "/usr/include/boost-1_42/boost/python/class.hpp"
# 1 "/usr/include/boost-1_42/boost/python/class_fwd.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/class_fwd.hpp"
namespace boost { namespace python {

template <
    class T

    , class X1 = ::boost::python::detail::not_specified
    , class X2 = ::boost::python::detail::not_specified
    , class X3 = ::boost::python::detail::not_specified
    >
class class_;

}}
# 13 "/usr/include/boost-1_42/boost/python/class.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/class.hpp" 1
# 12 "/usr/include/boost-1_42/boost/python/object/class.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 13 "/usr/include/boost-1_42/boost/python/object/class.hpp" 2

namespace boost { namespace python {

namespace objects {

struct class_base : python::api::object
{

    class_base(
        char const* name

        , std::size_t num_types
        , type_info const*const types


        , char const* doc = 0
        );




    void enable_pickling_(bool getstate_manages_dict);

 protected:
    void add_property(
        char const* name, object const& fget, char const* docstr);
    void add_property(char const* name,
        object const& fget, object const& fset, char const* docstr);

    void add_static_property(char const* name, object const& fget);
    void add_static_property(char const* name, object const& fget, object const& fset);


    void setattr(char const* name, object const&);




    void set_instance_size(std::size_t bytes);



    void def_no_init();



    void make_method_static(const char *method_name);
};

}}}
# 14 "/usr/include/boost-1_42/boost/python/class.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/object.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/object.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object_attributes.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/object_attributes.hpp"
# 1 "/usr/include/boost-1_42/boost/python/proxy.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/proxy.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object_operators.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/object_operators.hpp"
# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
# 12 "/usr/include/boost-1_42/boost/python/object_operators.hpp" 2
# 1 "/usr/include/boost-1_42/boost/iterator/detail/enable_if.hpp" 1
# 13 "/usr/include/boost-1_42/boost/iterator/detail/enable_if.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/iterator/detail/enable_if.hpp" 2







namespace boost
{

  namespace iterators
  {



    template<bool>
    struct enabled
    {
      template<typename T>
      struct base
      {
        typedef T type;
      };
    };






    template<>
    struct enabled<false>
    {
      template<typename T>
      struct base
      {
# 62 "/usr/include/boost-1_42/boost/iterator/detail/enable_if.hpp"
      };
    };


    template <class Cond,
              class Return>
    struct enable_if

      : enabled<(Cond::value)>::template base<Return>



    {



    };

  }

}

# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
# 85 "/usr/include/boost-1_42/boost/iterator/detail/enable_if.hpp" 2
# 13 "/usr/include/boost-1_42/boost/python/object_operators.hpp" 2


# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/object_operators.hpp" 2

namespace boost { namespace python { namespace api {

template <class X>
char is_object_operators_helper(object_operators<X> const*);

typedef char (&no_type)[2];
no_type is_object_operators_helper(...);

template <class X> X* make_ptr();

template <class L, class R = L>
struct is_object_operators
{
    enum {
        value
        = (sizeof(api::is_object_operators_helper(api::make_ptr<L>()))
           + sizeof(api::is_object_operators_helper(api::make_ptr<R>()))
           < 4
        )
    };
    typedef mpl::bool_<value> type;
};


template <class L, class R, class T>
struct enable_binary
  : boost::iterators::enable_if<is_object_operators<L,R>, T>
{};





template <class U>
object object_operators<U>::operator()() const
{
    object_cref2 f = *static_cast<U const*>(this);
    return call<object>(f.ptr());
}


template <class U>
inline
object_operators<U>::operator bool_type() const
{
    object_cref2 x = *static_cast<U const*>(this);
    int is_true = PyObject_IsTrue(x.ptr());
    if (is_true < 0) throw_error_already_set();
    return is_true ? &object::ptr : 0;
}

template <class U>
inline bool
object_operators<U>::operator!() const
{
    object_cref2 x = *static_cast<U const*>(this);
    int is_true = PyObject_IsTrue(x.ptr());
    if (is_true < 0) throw_error_already_set();
    return !is_true;
}
# 94 "/usr/include/boost-1_42/boost/python/object_operators.hpp"
 object operator >(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator >(L const& l, R const& r) { return object(l) > object(r); }
 object operator >=(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator >=(L const& l, R const& r) { return object(l) >= object(r); }
 object operator <(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator <(L const& l, R const& r) { return object(l) < object(r); }
 object operator <=(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator <=(L const& l, R const& r) { return object(l) <= object(r); }
 object operator ==(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator ==(L const& l, R const& r) { return object(l) == object(r); }
 object operator !=(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator !=(L const& l, R const& r) { return object(l) != object(r); }
 object operator +(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator +(L const& l, R const& r) { return object(l) + object(r); }
 object operator -(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator -(L const& l, R const& r) { return object(l) - object(r); }
 object operator *(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator *(L const& l, R const& r) { return object(l) * object(r); }
 object operator /(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator /(L const& l, R const& r) { return object(l) / object(r); }
 object operator %(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator %(L const& l, R const& r) { return object(l) % object(r); }
 object operator <<(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator <<(L const& l, R const& r) { return object(l) << object(r); }
 object operator >>(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator >>(L const& l, R const& r) { return object(l) >> object(r); }
 object operator &(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator &(L const& l, R const& r) { return object(l) & object(r); }
 object operator ^(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator ^(L const& l, R const& r) { return object(l) ^ object(r); }
 object operator |(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator |(L const& l, R const& r) { return object(l) | object(r); }
# 120 "/usr/include/boost-1_42/boost/python/object_operators.hpp"
 object& operator +=(object& l, object const& r); template <class R> object& operator +=(object& l, R const& r) { return l += object(r); }
 object& operator -=(object& l, object const& r); template <class R> object& operator -=(object& l, R const& r) { return l -= object(r); }
 object& operator *=(object& l, object const& r); template <class R> object& operator *=(object& l, R const& r) { return l *= object(r); }
 object& operator /=(object& l, object const& r); template <class R> object& operator /=(object& l, R const& r) { return l /= object(r); }
 object& operator %=(object& l, object const& r); template <class R> object& operator %=(object& l, R const& r) { return l %= object(r); }
 object& operator <<=(object& l, object const& r); template <class R> object& operator <<=(object& l, R const& r) { return l <<= object(r); }
 object& operator >>=(object& l, object const& r); template <class R> object& operator >>=(object& l, R const& r) { return l >>= object(r); }
 object& operator &=(object& l, object const& r); template <class R> object& operator &=(object& l, R const& r) { return l &= object(r); }
 object& operator ^=(object& l, object const& r); template <class R> object& operator ^=(object& l, R const& r) { return l ^= object(r); }
 object& operator |=(object& l, object const& r); template <class R> object& operator |=(object& l, R const& r) { return l |= object(r); }


}}}

# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
# 135 "/usr/include/boost-1_42/boost/python/object_operators.hpp" 2
# 10 "/usr/include/boost-1_42/boost/python/proxy.hpp" 2

namespace boost { namespace python { namespace api {

template <class Policies>
class proxy : public object_operators<proxy<Policies> >
{
    typedef typename Policies::key_type key_type;


    typedef proxy const& assignment_self;



 public:
    proxy(object const& target, key_type const& key);
    operator object() const;


    proxy const& operator=(assignment_self) const;

    template <class T>
    inline proxy const& operator=(T const& rhs) const
    {
        Policies::set(m_target, m_key, object(rhs));
        return *this;
    }

 public:
    void del() const;

 private:
    object m_target;
    key_type m_key;
};


template <class T>
inline void del(proxy<T> const& x)
{
    x.del();
}





template <class Policies>
inline proxy<Policies>::proxy(object const& target, key_type const& key)
    : m_target(target), m_key(key)
{}

template <class Policies>
inline proxy<Policies>::operator object() const
{
    return Policies::get(m_target, m_key);
}


template <class Policies>
inline proxy<Policies> const& proxy<Policies>::operator=(typename proxy::assignment_self rhs) const
{
    return *this = python::object(rhs);
}
# 81 "/usr/include/boost-1_42/boost/python/proxy.hpp"
template <class Policies, class R> proxy<Policies> const& operator +=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old += rhs); }
template <class Policies, class R> proxy<Policies> const& operator -=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old -= rhs); }
template <class Policies, class R> proxy<Policies> const& operator *=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old *= rhs); }
template <class Policies, class R> proxy<Policies> const& operator /=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old /= rhs); }
template <class Policies, class R> proxy<Policies> const& operator %=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old %= rhs); }
template <class Policies, class R> proxy<Policies> const& operator <<=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old <<= rhs); }
template <class Policies, class R> proxy<Policies> const& operator >>=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old >>= rhs); }
template <class Policies, class R> proxy<Policies> const& operator &=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old &= rhs); }
template <class Policies, class R> proxy<Policies> const& operator ^=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old ^= rhs); }
template <class Policies, class R> proxy<Policies> const& operator |=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old |= rhs); }


template <class Policies>
inline void proxy<Policies>::del() const
{
    Policies::del(m_target, m_key);
}

}}}
# 11 "/usr/include/boost-1_42/boost/python/object_attributes.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/object_protocol.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/object_protocol.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object_protocol_core.hpp" 1
# 12 "/usr/include/boost-1_42/boost/python/object_protocol_core.hpp"
namespace boost { namespace python {

namespace api
{
  class object;

  object getattr(object const& target, object const& key);
  object getattr(object const& target, object const& key, object const& default_);
  void setattr(object const& target, object const& key, object const& value);
  void delattr(object const& target, object const& key);



  object getattr(object const& target, char const* key);
  object getattr(object const& target, char const* key, object const& default_);
  void setattr(object const& target, char const* key, object const& value);
  void delattr(object const& target, char const* key);

  object getitem(object const& target, object const& key);
  void setitem(object const& target, object const& key, object const& value);
  void delitem(object const& target, object const& key);

  object getslice(object const& target, handle<> const& begin, handle<> const& end);
  void setslice(object const& target, handle<> const& begin, handle<> const& end, object const& value);
  void delslice(object const& target, handle<> const& begin, handle<> const& end);
}

using api::getattr;
using api::setattr;
using api::delattr;

using api::getitem;
using api::setitem;
using api::delitem;

using api::getslice;
using api::setslice;
using api::delslice;

}}
# 11 "/usr/include/boost-1_42/boost/python/object_protocol.hpp" 2




namespace boost { namespace python { namespace api {
# 26 "/usr/include/boost-1_42/boost/python/object_protocol.hpp"
template <class Target, class Key>
object getattr(Target const& target, Key const& key )
{
    return getattr(object(target), object(key));
}

template <class Target, class Key, class Default>
object getattr(Target const& target, Key const& key, Default const& default_ )
{
    return getattr(object(target), object(key), object(default_));
}


template <class Key, class Value>
void setattr(object const& target, Key const& key, Value const& value )
{
    setattr(target, object(key), object(value));
}

template <class Key>
void delattr(object const& target, Key const& key )
{
    delattr(target, object(key));
}

template <class Target, class Key>
object getitem(Target const& target, Key const& key )
{
    return getitem(object(target), object(key));
}


template <class Key, class Value>
void setitem(object const& target, Key const& key, Value const& value )
{
    setitem(target, object(key), object(value));
}

template <class Key>
void delitem(object const& target, Key const& key )
{
    delitem(target, object(key));
}

template <class Target, class Begin, class End>
object getslice(Target const& target, Begin const& begin, End const& end)
{
    return getslice(object(target), object(begin), object(end));
}

template <class Begin, class End, class Value>
void setslice(object const& target, Begin const& begin, End const& end, Value const& value)
{
    setslice(target, object(begin), object(end), object(value));
}

template <class Begin, class End>
void delslice(object const& target, Begin const& begin, End const& end)
{
    delslice(target, object(begin), object(end));
}

}}}
# 13 "/usr/include/boost-1_42/boost/python/object_attributes.hpp" 2

namespace boost { namespace python { namespace api {

struct const_attribute_policies
{
    typedef char const* key_type;
    static object get(object const& target, char const* key);
    static object get(object const& target, object const& key);
};

struct attribute_policies : const_attribute_policies
{
    static object const& set(object const& target, char const* key, object const& value);
    static void del(object const&target, char const* key);
};

struct const_objattribute_policies
{
    typedef object const key_type;
    static object get(object const& target, object const& key);
};

struct objattribute_policies : const_objattribute_policies
{
    static object const& set(object const& target, object const& key, object const& value);
    static void del(object const&target, object const& key);
};




template <class U>
inline object_attribute object_operators<U>::attr(char const* name)
{
    object_cref2 x = *static_cast<U*>(this);
    return object_attribute(x, name);
}

template <class U>
inline const_object_attribute object_operators<U>::attr(char const* name) const
{
    object_cref2 x = *static_cast<U const*>(this);
    return const_object_attribute(x, name);
}

template <class U>
inline object_objattribute object_operators<U>::attr(object const& name)
{
    object_cref2 x = *static_cast<U*>(this);
    return object_objattribute(x, name);
}

template <class U>
inline const_object_objattribute object_operators<U>::attr(object const& name) const
{
    object_cref2 x = *static_cast<U const*>(this);
    return const_object_objattribute(x, name);
}

inline object const_attribute_policies::get(object const& target, char const* key)
{
    return python::getattr(target, key);
}

inline object const_objattribute_policies::get(object const& target, object const& key)
{
    return python::getattr(target, key);
}

inline object const& attribute_policies::set(
    object const& target
    , char const* key
    , object const& value)
{
    python::setattr(target, key, value);
    return value;
}

inline object const& objattribute_policies::set(
    object const& target
    , object const& key
    , object const& value)
{
    python::setattr(target, key, value);
    return value;
}

inline void attribute_policies::del(
    object const& target
    , char const* key)
{
    python::delattr(target, key);
}

inline void objattribute_policies::del(
    object const& target
    , object const& key)
{
    python::delattr(target, key);
}

}}}
# 11 "/usr/include/boost-1_42/boost/python/object.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object_items.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/object_items.hpp"
namespace boost { namespace python { namespace api {

struct const_item_policies
{
    typedef object key_type;
    static object get(object const& target, object const& key);
};

struct item_policies : const_item_policies
{
    static object const& set(object const& target, object const& key, object const& value);
    static void del(object const& target, object const& key);
};




template <class U>
inline object_item
object_operators<U>::operator[](object_cref key)
{
    object_cref2 x = *static_cast<U*>(this);
    return object_item(x, key);
}

template <class U>
inline const_object_item
object_operators<U>::operator[](object_cref key) const
{
    object_cref2 x = *static_cast<U const*>(this);
    return const_object_item(x, key);
}


template <class U>
template <class T>
inline const_object_item
object_operators<U>::operator[](T const& key) const
{
    return (*this)[object(key)];
}

template <class U>
template <class T>
inline object_item
object_operators<U>::operator[](T const& key)
{
    return (*this)[object(key)];
}



inline object const_item_policies::get(object const& target, object const& key)
{
    return getitem(target, key);
}

inline object const& item_policies::set(
    object const& target
    , object const& key
    , object const& value)
{
    setitem(target, key, value);
    return value;
}

inline void item_policies::del(
    object const& target
    , object const& key)
{
    delitem(target, key);
}

}}}
# 12 "/usr/include/boost-1_42/boost/python/object.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object_slices.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/object_slices.hpp"
namespace boost { namespace python { namespace api {

struct const_slice_policies
{
    typedef std::pair<handle<>, handle<> > key_type;
    static object get(object const& target, key_type const& key);
};

struct slice_policies : const_slice_policies
{
    static object const& set(object const& target, key_type const& key, object const& value);
    static void del(object const& target, key_type const& key);
};

template <class T, class U>
inline slice_policies::key_type slice_key(T x, U y)
{
    return slice_policies::key_type(handle<>(x), handle<>(y));
}




template <class U>
object_slice
object_operators<U>::slice(object_cref start, object_cref finish)
{
    object_cref2 x = *static_cast<U*>(this);
    return object_slice(x, api::slice_key(borrowed(start.ptr()), borrowed(finish.ptr())));
}

template <class U>
const_object_slice
object_operators<U>::slice(object_cref start, object_cref finish) const
{
    object_cref2 x = *static_cast<U const*>(this);
    return const_object_slice(x, api::slice_key(borrowed(start.ptr()), borrowed(finish.ptr())));
}

template <class U>
object_slice
object_operators<U>::slice(slice_nil, object_cref finish)
{
    object_cref2 x = *static_cast<U*>(this);
    return object_slice(x, api::slice_key(allow_null((PyObject*)0), borrowed(finish.ptr())));
}

template <class U>
const_object_slice
object_operators<U>::slice(slice_nil, object_cref finish) const
{
    object_cref2 x = *static_cast<U const*>(this);
    return const_object_slice(x, api::slice_key(allow_null((PyObject*)0), borrowed(finish.ptr())));
}

template <class U>
object_slice
object_operators<U>::slice(slice_nil, slice_nil)
{
    object_cref2 x = *static_cast<U*>(this);
    return object_slice(x, api::slice_key(allow_null((PyObject*)0), allow_null((PyObject*)0)));
}

template <class U>
const_object_slice
object_operators<U>::slice(slice_nil, slice_nil) const
{
    object_cref2 x = *static_cast<U const*>(this);
    return const_object_slice(x, api::slice_key(allow_null((PyObject*)0), allow_null((PyObject*)0)));
}

template <class U>
object_slice
object_operators<U>::slice(object_cref start, slice_nil)
{
    object_cref2 x = *static_cast<U*>(this);
    return object_slice(x, api::slice_key(borrowed(start.ptr()), allow_null((PyObject*)0)));
}

template <class U>
const_object_slice
object_operators<U>::slice(object_cref start, slice_nil) const
{
    object_cref2 x = *static_cast<U const*>(this);
    return const_object_slice(x, api::slice_key(borrowed(start.ptr()), allow_null((PyObject*)0)));
}

template <class U>
template <class T, class V>
inline const_object_slice
object_operators<U>::slice(T const& start, V const& end) const
{
    return this->slice(
        typename slice_bound<T>::type(start)
        , typename slice_bound<V>::type(end));
}

template <class U>
template <class T, class V>
inline object_slice
object_operators<U>::slice(T const& start, V const& end)
{
    return this->slice(
        typename slice_bound<T>::type(start)
        , typename slice_bound<V>::type(end));
}



inline object const_slice_policies::get(object const& target, key_type const& key)
{
    return getslice(target, key.first, key.second);
}

inline object const& slice_policies::set(
    object const& target
    , key_type const& key
    , object const& value)
{
    setslice(target, key.first, key.second, value);
    return value;
}

inline void slice_policies::del(
    object const& target
    , key_type const& key)
{
    delslice(target, key.first, key.second);
}

}}}
# 13 "/usr/include/boost-1_42/boost/python/object.hpp" 2



namespace boost { namespace python {

    inline ssize_t len(object const& obj)
    {
        ssize_t result = PyObject_Size(obj.ptr());
        if (PyErr_Occurred()) throw_error_already_set();
        return result;
    }

}}
# 16 "/usr/include/boost-1_42/boost/python/class.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/data_members.hpp" 1
# 12 "/usr/include/boost-1_42/boost/python/data_members.hpp"
# 1 "/usr/include/boost-1_42/boost/python/return_value_policy.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/return_value_policy.hpp"
namespace boost { namespace python {

template <class ResultConverterGenerator, class BasePolicy_ = default_call_policies>
struct return_value_policy : BasePolicy_
{
    typedef ResultConverterGenerator result_converter;
};

}}
# 13 "/usr/include/boost-1_42/boost/python/data_members.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/return_by_value.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/return_by_value.hpp"
namespace boost { namespace python {

struct return_by_value
{
    template <class R>
    struct apply
    {
       typedef to_python_value<
           typename detail::value_arg<R>::type
       > type;
    };
};

}}
# 14 "/usr/include/boost-1_42/boost/python/data_members.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/return_internal_reference.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/return_internal_reference.hpp"
# 1 "/usr/include/boost-1_42/boost/python/reference_existing_object.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/reference_existing_object.hpp"
namespace boost { namespace python {

namespace detail
{
  template <class R>
  struct reference_existing_object_requires_a_pointer_or_reference_return_type

  {}

  ;
}

template <class T> struct to_python_value;

struct reference_existing_object
{
    template <class T>
    struct apply
    {
        static const bool ok = is_pointer<T>::value || is_reference<T>::value
                                                                      ;

        typedef typename mpl::if_c<
            ok
            , to_python_indirect<T, detail::make_reference_holder>
            , detail::reference_existing_object_requires_a_pointer_or_reference_return_type<T>
        >::type type;
    };
};

}}
# 12 "/usr/include/boost-1_42/boost/python/return_internal_reference.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/with_custodian_and_ward.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/with_custodian_and_ward.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/life_support.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/object/life_support.hpp"
namespace boost { namespace python { namespace objects {

 PyObject* make_nurse_and_patient(PyObject* nurse, PyObject* patient);

}}}
# 12 "/usr/include/boost-1_42/boost/python/with_custodian_and_ward.hpp" 2


namespace boost { namespace python {

namespace detail
{
  template <std::size_t N>
  struct get_prev
  {
      template <class ArgumentPackage>
      static PyObject* execute(ArgumentPackage const& args, PyObject* = 0)
      {
          int const pre_n = static_cast<int>(N) - 1;
          return detail::get(mpl::int_<pre_n>(), args);
      }
  };
  template <>
  struct get_prev<0>
  {
      template <class ArgumentPackage>
      static PyObject* execute(ArgumentPackage const&, PyObject* zeroth)
      {
          return zeroth;
      }
  };
}
template <
    std::size_t custodian
  , std::size_t ward
  , class BasePolicy_ = default_call_policies
>
struct with_custodian_and_ward : BasePolicy_
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((custodian != ward) == 0 ? false : true) >)> boost_static_assert_typedef_45;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((custodian > 0) == 0 ? false : true) >)> boost_static_assert_typedef_46;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((ward > 0) == 0 ? false : true) >)> boost_static_assert_typedef_47;

    template <class ArgumentPackage>
    static bool precall(ArgumentPackage const& args_)
    {
        unsigned arity_ = detail::arity(args_);
        if (custodian > arity_ || ward > arity_)
        {
            PyErr_SetString(
                PyExc_IndexError
              , "boost::python::with_custodian_and_ward: argument index out of range"
            );
            return false;
        }

        PyObject* patient = detail::get_prev<ward>::execute(args_);
        PyObject* nurse = detail::get_prev<custodian>::execute(args_);

        PyObject* life_support = python::objects::make_nurse_and_patient(nurse, patient);
        if (life_support == 0)
            return false;

        bool result = BasePolicy_::precall(args_);

        if (!result) {
            if ( --((PyObject*)(life_support))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(life_support)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(life_support))));
        }

        return result;
    }
};

template <std::size_t custodian, std::size_t ward, class BasePolicy_ = default_call_policies>
struct with_custodian_and_ward_postcall : BasePolicy_
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((custodian != ward) == 0 ? false : true) >)> boost_static_assert_typedef_82;

    template <class ArgumentPackage>
    static PyObject* postcall(ArgumentPackage const& args_, PyObject* result)
    {
        std::size_t arity_ = detail::arity(args_);






        if ( (std::max)(custodian, ward) > arity_ )

        {
            PyErr_SetString(
                PyExc_IndexError
              , "boost::python::with_custodian_and_ward_postcall: argument index out of range"
            );
            return 0;
        }

        PyObject* patient = detail::get_prev<ward>::execute(args_, result);
        PyObject* nurse = detail::get_prev<custodian>::execute(args_, result);

        if (nurse == 0) return 0;

        result = BasePolicy_::postcall(args_, result);
        if (result == 0)
            return 0;

        if (python::objects::make_nurse_and_patient(nurse, patient) == 0)
        {
            if ((result) == __null) ; else if ( --((PyObject*)(result))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(result)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(result))));
            return 0;
        }
        return result;
    }
};


}}
# 13 "/usr/include/boost-1_42/boost/python/return_internal_reference.hpp" 2


namespace boost { namespace python {

namespace detail
{
  template <std::size_t>
  struct return_internal_reference_owner_arg_must_be_greater_than_zero

  {}

  ;
}

template <std::size_t owner_arg = 1, class BasePolicy_ = default_call_policies>
struct return_internal_reference
    : with_custodian_and_ward_postcall<0, owner_arg, BasePolicy_>
{
 private:
    static const bool legal = owner_arg > 0;
 public:
    typedef typename mpl::if_c<
        legal
        , reference_existing_object
        , detail::return_internal_reference_owner_arg_must_be_greater_than_zero<owner_arg>
    >::type result_converter;
};

}}
# 15 "/usr/include/boost-1_42/boost/python/data_members.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/make_function.hpp" 1
# 12 "/usr/include/boost-1_42/boost/python/make_function.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/make_function.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/object/function_object.hpp" 1







# 1 "/usr/include/boost-1_42/boost/function/function2.hpp" 1
# 11 "/usr/include/boost-1_42/boost/function/function2.hpp"
# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
# 23 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp"
# 1 "/usr/include/boost-1_42/boost/function/function_template.hpp" 1
# 81 "/usr/include/boost-1_42/boost/function/function_template.hpp"
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1
        >
      struct function_invoker2
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0 , a1);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1
        >
      struct void_function_invoker2
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0 , a1);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct function_obj_invoker2
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct void_function_obj_invoker2
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct function_ref_invoker2
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct void_function_ref_invoker2
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1
      >
      struct function_mem_invoker2
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0 , a1);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1
      >
      struct function_void_mem_invoker2
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0 , a1);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1
      >
      struct get_function_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker2<
                            FunctionPtr,
                            R ,
                            T0 , T1
                          >,
                          function_invoker2<
                            FunctionPtr,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
       >
      struct get_function_obj_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >,
                          function_obj_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
       >
      struct get_function_ref_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >,
                          function_ref_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1
       >
      struct get_member_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker2<
                            MemberPtr,
                            R ,
                            T0 , T1
                          >,
                          function_mem_invoker2<
                            MemberPtr,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_42/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker2 { };


      template<>
      struct get_invoker2<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_function_invoker2<
                             FunctionPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker2<
                             FunctionPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker2<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_member_invoker2<
                             MemberPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker2<
                             MemberPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker2<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_function_obj_invoker2<
                             FunctionObj,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker2<
                             FunctionObj,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker2<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_function_ref_invoker2<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker2<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_42/boost/function/function_template.hpp"
      template<typename R , typename T0 , typename T1>
      struct basic_vtable2
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1
  >
  class function2 : public function_base







    , public std::binary_function<T0,T1,R>



  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable2<
              R , T0 , T1>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 2;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };




    typedef T0 first_argument_type;
    typedef T1 second_argument_type;


    static const int arity = 2;
    typedef T0 arg1_type; typedef T1 arg2_type;

    typedef function2 self_type;

    function2() : function_base() { }



    template<typename Functor>
    function2(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function2(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function2(clear_type*) : function_base() { }







    function2(const function2& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function2() { clear(); }
# 766 "/usr/include/boost-1_42/boost/function/function_template.hpp"
    result_type operator()( T0 a0 , T1 a1) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function2&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function2& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_42/boost/function/function_template.hpp"
    function2& operator=(const function2& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function2& other)
    {
      if (&other == this)
        return;

      function2 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function2& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker2<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker2<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function2& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1>
  inline void swap(function2<
                     R ,
                     T0 , T1
                   >& f1,
                   function2<
                     R ,
                     T0 , T1
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0 , typename T1>
  typename function2<
      R , T0 , T1>::result_type
  inline
  function2<R , T0 , T1>
  ::operator()( T0 a0 , T1 a1) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0 , a1);
  }



template<typename R , typename T0 , typename T1>
  void operator==(const function2<
                          R ,
                          T0 , T1>&,
                  const function2<
                          R ,
                          T0 , T1>&);
template<typename R , typename T0 , typename T1>
  void operator!=(const function2<
                          R ,
                          T0 , T1>&,
                  const function2<
                          R ,
                          T0 , T1>& );
# 1041 "/usr/include/boost-1_42/boost/function/function_template.hpp"
template<typename R ,
         typename T0 , typename T1>
class function<R ( T0 , T1)>
  : public function2<R , T0 , T1>
{
  typedef function2<R , T0 , T1> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};




}
# 24 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 2
# 12 "/usr/include/boost-1_42/boost/function/function2.hpp" 2
# 9 "/usr/include/boost-1_42/boost/python/object/function_object.hpp" 2




namespace boost { namespace python {

namespace objects
{
  api::object function_object(
      py_function const& f
      , python::detail::keyword_range const&);

  api::object function_object(
      py_function const& f
      , python::detail::keyword_range const&);

  api::object function_object(py_function const& f);





  void add_to_namespace(
      object const& name_space, char const* name, object const& attribute);

  void add_to_namespace(
      object const& name_space, char const* name, object const& attribute, char const* doc);
}

}}
# 15 "/usr/include/boost-1_42/boost/python/make_function.hpp" 2




namespace boost { namespace python {

namespace detail
{






  template <class F, class CallPolicies, class Sig>
  object make_function_aux(
      F f
      , CallPolicies const& p
      , Sig const&
      )
  {
      return objects::function_object(
          detail::caller<F,CallPolicies,Sig>(f, p)
      );
  }





  template <class F, class CallPolicies, class Sig, class NumKeywords>
  object make_function_aux(
      F f
      , CallPolicies const& p
      , Sig const&
      , detail::keyword_range const& kw
      , NumKeywords
      )
  {
      enum { arity = mpl::size<Sig>::value - 1 };

      typedef typename detail::error::more_keywords_than_function_arguments<
          NumKeywords::value, arity
          >::too_many_keywords assertion;

      return objects::function_object(
          detail::caller<F,CallPolicies,Sig>(f, p)
        , kw);
  }






  template <class F, class CallPolicies, class Keywords>
  object make_function_dispatch(F f, CallPolicies const& policies, Keywords const& kw, mpl::true_)
  {
      return detail::make_function_aux(
          f
        , policies
        , detail::get_signature(f)
        , kw.range()
        , mpl::int_<Keywords::size>()
      );
  }

  template <class F, class CallPolicies, class Signature>
  object make_function_dispatch(F f, CallPolicies const& policies, Signature const& sig, mpl::false_)
  {
      return detail::make_function_aux(
          f
        , policies
        , sig
      );
  }


 }






template <class F>
object make_function(F f)
{
    return detail::make_function_aux(
        f,default_call_policies(), detail::get_signature(f));
}

template <class F, class CallPolicies>
object make_function(F f, CallPolicies const& policies)
{
    return detail::make_function_aux(
        f, policies, detail::get_signature(f));
}

template <class F, class CallPolicies, class KeywordsOrSignature>
object make_function(
    F f
  , CallPolicies const& policies
  , KeywordsOrSignature const& keywords_or_signature)
{
    typedef typename
        detail::is_reference_to_keywords<KeywordsOrSignature&>::type
        is_kw;

    return detail::make_function_dispatch(
        f
      , policies
      , keywords_or_signature
      , is_kw()
    );
}

template <class F, class CallPolicies, class Keywords, class Signature>
object make_function(
    F f
  , CallPolicies const& policies
  , Keywords const& kw
  , Signature const& sig
 )
{
    return detail::make_function_aux(
          f
        , policies
        , sig
        , kw.range()
        , mpl::int_<Keywords::size>()
      );
}


}}
# 16 "/usr/include/boost-1_42/boost/python/data_members.hpp" 2
# 37 "/usr/include/boost-1_42/boost/python/data_members.hpp"
namespace boost { namespace python {
# 46 "/usr/include/boost-1_42/boost/python/data_members.hpp"
namespace detail
{



  template <class Data, class Class>
  struct member
  {
   public:
      member(Data Class::*which) : m_which(which) {}

      Data& operator()(Class& c) const
      {
          return c.*m_which;
      }

      void operator()(Class& c, typename value_arg<Data>::type d) const
      {
          c.*m_which = d;
      }
   private:
      Data Class::*m_which;
  };



  template <class Data>
  struct datum
  {
   public:
      datum(Data *which) : m_which(which) {}

      Data& operator()() const
      {
          return *m_which;
      }

      void operator()(typename value_arg<Data>::type d) const
      {
          *m_which = d;
      }
   private:
      Data *m_which;
  };
# 102 "/usr/include/boost-1_42/boost/python/data_members.hpp"
  template <class T>
  struct default_getter_by_ref
      : mpl::and_<
          mpl::bool_<
              to_python_value<
                  typename value_arg<T>::type
              >::uses_registry
          >
        , indirect_traits::is_reference_to_class<
              typename value_arg<T>::type
          >
       >
  {
  };
# 125 "/usr/include/boost-1_42/boost/python/data_members.hpp"
  template <class T>
  struct default_member_getter_policy
    : mpl::if_<
          default_getter_by_ref<T>
        , return_internal_reference<>
        , return_value_policy<return_by_value>
      >
  {};



  template <class T>
  struct default_datum_getter_policy
    : mpl::if_<
          default_getter_by_ref<T>
        , return_value_policy<reference_existing_object>
        , return_value_policy<return_by_value>
      >
  {};
# 162 "/usr/include/boost-1_42/boost/python/data_members.hpp"
  template <class D, class Policies>
  inline object make_getter(D* d, Policies const& policies, mpl::false_, int)
  {
      return python::make_function(
          detail::datum<D>(d), policies, mpl::vector1<D&>()
      );
  }


  template <class D>
  inline object make_getter(D* d, not_specified, mpl::false_, long)
  {
      typedef typename default_datum_getter_policy<D>::type policies;
      return detail::make_getter(d, policies(), mpl::false_(), 0);
  }


  template <class C, class D, class Policies>
  inline object make_getter(D C::*pm, Policies const& policies, mpl::true_, int)
  {



      typedef C Class;

      return python::make_function(
          detail::member<D,Class>(pm)
        , policies
        , mpl::vector2<D&,Class&>()
      );
  }


  template <class C, class D>
  inline object make_getter(D C::*pm, not_specified, mpl::true_, long)
  {
      typedef typename default_member_getter_policy<D>::type policies;
      return detail::make_getter(pm, policies(), mpl::true_(), 0);
  }


  template <class D, class P>
  inline object make_getter(D& d, P& p, mpl::false_, ...)
  {

      return detail::make_getter(&d, p, mpl::false_(), 0L);
  }
# 219 "/usr/include/boost-1_42/boost/python/data_members.hpp"
  template <class D, class Policies>
  inline object make_setter(D* p, Policies const& policies, mpl::false_, int)
  {
      return python::make_function(
          detail::datum<D>(p), policies, mpl::vector2<void,D const&>()
      );
  }


  template <class C, class D, class Policies>
  inline object make_setter(D C::*pm, Policies const& policies, mpl::true_, int)
  {
      return python::make_function(
          detail::member<D,C>(pm)
        , policies
        , mpl::vector3<void, C&, D const&>()
      );
  }


  template <class D, class Policies>
  inline object make_setter(D& x, Policies const& policies, mpl::false_, ...)
  {
      return detail::make_setter(&x, policies, mpl::false_(), 0L);
  }
}
# 253 "/usr/include/boost-1_42/boost/python/data_members.hpp"
template <class D, class Policies>
inline object make_getter(D& d, Policies const& policies)
{
    return detail::make_getter(d, policies, is_member_pointer<D>(), 0L);
}

template <class D, class Policies>
inline object make_getter(D const& d, Policies const& policies)
{
    return detail::make_getter(d, policies, is_member_pointer<D>(), 0L);
}

template <class D>
inline object make_getter(D& x)
{
    detail::not_specified policy
        = detail::not_specified();
    return detail::make_getter(x, policy, is_member_pointer<D>(), 0L);
}


template <class D>
inline object make_getter(D const& d)
{
    detail::not_specified policy
        = detail::not_specified();
    return detail::make_getter(d, policy, is_member_pointer<D>(), 0L);
}
# 290 "/usr/include/boost-1_42/boost/python/data_members.hpp"
template <class D, class Policies>
inline object make_setter(D& x, Policies const& policies)
{
    return detail::make_setter(x, policies, is_member_pointer<D>(), 0);
}

template <class D, class Policies>
inline object make_setter(D const& x, Policies const& policies)
{
    return detail::make_setter(x, policies, is_member_pointer<D>(), 0);
}

template <class D>
inline object make_setter(D& x)
{
    return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
}


template <class D>
inline object make_setter(D const& x)
{
    return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
}


}}
# 18 "/usr/include/boost-1_42/boost/python/class.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/class.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/init.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/init.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/make_keyword_range_fn.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/detail/make_keyword_range_fn.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 32 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 33 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2

namespace boost { namespace python { namespace objects {

template <int nargs> struct make_holder;





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<0>
{
    template <class Holder, class ArgList>
    struct apply
    {
# 82 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
        static void execute(



            PyObject *p

            )
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p ))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<1>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<2>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<3>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<4>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<5>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<6>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;


        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<7>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;


        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;


        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<8>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;


        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;


        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;


        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<9>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;


        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;


        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;


        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;


        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<10>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;


        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;


        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;


        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;


        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;


        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<11>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;


        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;


        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;


        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;


        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;


        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;


        typedef typename mpl::deref<iter10>::type t10; typedef typename forward<t10>::type f10; typedef typename mpl::next<iter10>::type iter11;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9 , t10 a10)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9) , f10(a10)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<12>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;


        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;


        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;


        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;


        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;


        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;


        typedef typename mpl::deref<iter10>::type t10; typedef typename forward<t10>::type f10; typedef typename mpl::next<iter10>::type iter11;


        typedef typename mpl::deref<iter11>::type t11; typedef typename forward<t11>::type f11; typedef typename mpl::next<iter11>::type iter12;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9 , t10 a10 , t11 a11)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9) , f10(a10) , f11(a11)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<13>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;


        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;


        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;


        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;


        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;


        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;


        typedef typename mpl::deref<iter10>::type t10; typedef typename forward<t10>::type f10; typedef typename mpl::next<iter10>::type iter11;


        typedef typename mpl::deref<iter11>::type t11; typedef typename forward<t11>::type f11; typedef typename mpl::next<iter11>::type iter12;


        typedef typename mpl::deref<iter12>::type t12; typedef typename forward<t12>::type f12; typedef typename mpl::next<iter12>::type iter13;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9 , t10 a10 , t11 a11 , t12 a12)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9) , f10(a10) , f11(a11) , f12(a12)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<14>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;


        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;


        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;


        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;


        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;


        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;


        typedef typename mpl::deref<iter10>::type t10; typedef typename forward<t10>::type f10; typedef typename mpl::next<iter10>::type iter11;


        typedef typename mpl::deref<iter11>::type t11; typedef typename forward<t11>::type f11; typedef typename mpl::next<iter11>::type iter12;


        typedef typename mpl::deref<iter12>::type t12; typedef typename forward<t12>::type f12; typedef typename mpl::next<iter12>::type iter13;


        typedef typename mpl::deref<iter13>::type t13; typedef typename forward<t13>::type f13; typedef typename mpl::next<iter13>::type iter14;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9 , t10 a10 , t11 a11 , t12 a12 , t13 a13)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9) , f10(a10) , f11(a11) , f12(a12) , f13(a13)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"




template <>
struct make_holder<15>
{
    template <class Holder, class ArgList>
    struct apply
    {




        typedef typename mpl::begin<ArgList>::type iter0;
# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;


        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;


        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;


        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;


        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;


        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;


        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;


        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;


        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;


        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;


        typedef typename mpl::deref<iter10>::type t10; typedef typename forward<t10>::type f10; typedef typename mpl::next<iter10>::type iter11;


        typedef typename mpl::deref<iter11>::type t11; typedef typename forward<t11>::type f11; typedef typename mpl::next<iter11>::type iter12;


        typedef typename mpl::deref<iter12>::type t12; typedef typename forward<t12>::type f12; typedef typename mpl::next<iter12>::type iter13;


        typedef typename mpl::deref<iter13>::type t13; typedef typename forward<t13>::type f13; typedef typename mpl::next<iter13>::type iter14;


        typedef typename mpl::deref<iter14>::type t14; typedef typename forward<t14>::type f14; typedef typename mpl::next<iter14>::type iter15;
# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2


        static void execute(



            PyObject *p

            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9 , t10 a10 , t11 a11 , t12 a12 , t13 a13 , t14 a14)
        {
            typedef instance<Holder> instance_t;

            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
            try {
                (new (memory) Holder(
                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9) , f10(a10) , f11(a11) , f12(a12) , f13(a13) , f14(a14)))->install(p);
            }
            catch(...) {
                Holder::deallocate(p, memory);
                throw;
            }
        }
    };
};
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 43 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2



}}}
# 12 "/usr/include/boost-1_42/boost/python/detail/make_keyword_range_fn.hpp" 2




namespace boost { namespace python { namespace detail {
# 25 "/usr/include/boost-1_42/boost/python/detail/make_keyword_range_fn.hpp"
template <class F, class Policies>
object make_keyword_range_function(
    F f
  , Policies const& policies
  , keyword_range const& kw)
{
    return detail::make_function_aux(
        f, policies, detail::get_signature(f), kw, mpl::int_<0>());
}

template <class F, class Policies, class Signature>
object make_keyword_range_function(
    F f
  , Policies const& policies
  , keyword_range const& kw
  , Signature const& sig)
{
    return detail::make_function_aux(
        f, policies, sig, kw, mpl::int_<0>());
}
# 53 "/usr/include/boost-1_42/boost/python/detail/make_keyword_range_fn.hpp"
template <class ArgList, class Arity, class Holder, class CallPolicies>
object make_keyword_range_constructor(
    CallPolicies const& policies
    , detail::keyword_range const& kw
    , Holder* = 0
    , ArgList* = 0, Arity* = 0)
{



    return detail::make_keyword_range_function(
        objects::make_holder<Arity::value>
            ::template apply<Holder,ArgList>::execute
        , policies
        , kw);
}

}}}
# 17 "/usr/include/boost-1_42/boost/python/init.hpp" 2






# 1 "/usr/include/boost-1_42/boost/mpl/empty.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/empty.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/empty_impl.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/empty_impl.hpp"
namespace boost { namespace mpl {




template< typename Tag >
struct empty_impl
{
    template< typename Sequence > struct apply
        : is_same<
              typename begin<Sequence>::type
            , typename end<Sequence>::type
            >
    {
    };
};

 template<> struct empty_impl<non_sequence_tag> {};

}}
# 20 "/usr/include/boost-1_42/boost/mpl/empty.hpp" 2



namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct empty
    : empty_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct empty< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : empty< T1 > { }; }; template< typename Tag > struct lambda< empty< na > , Tag , int_<-1> > { typedef false_ is_le; typedef empty< na > result_; typedef empty< na > type; }; namespace aux { template< typename T1 > struct template_arity< empty< T1 > > : int_<1> { }; template<> struct template_arity< empty< na > > : int_<-1> { }; }

}}
# 24 "/usr/include/boost-1_42/boost/python/init.hpp" 2



# 1 "/usr/include/boost-1_42/boost/mpl/joint_view.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/joint_view.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/joint_iter.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/joint_iter.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/lambda_spec.hpp" 1
# 21 "/usr/include/boost-1_42/boost/mpl/aux_/joint_iter.hpp" 2






namespace boost { namespace mpl {



template<
      typename Iterator1
    , typename LastIterator1
    , typename Iterator2
    >
struct joint_iter
{
    typedef Iterator1 base;
    typedef forward_iterator_tag category;
};

template<
      typename LastIterator1
    , typename Iterator2
    >
struct joint_iter<LastIterator1,LastIterator1,Iterator2>
{
    typedef Iterator2 base;
    typedef forward_iterator_tag category;
};


template< typename I1, typename L1, typename I2 >
struct deref< joint_iter<I1,L1,I2> >
{
    typedef typename joint_iter<I1,L1,I2>::base base_;
    typedef typename deref<base_>::type type;
};

template< typename I1, typename L1, typename I2 >
struct next< joint_iter<I1,L1,I2> >
{
    typedef joint_iter< typename mpl::next<I1>::type,L1,I2 > type;
};

template< typename L1, typename I2 >
struct next< joint_iter<L1,L1,I2> >
{
    typedef joint_iter< L1,L1,typename mpl::next<I2>::type > type;
};
# 116 "/usr/include/boost-1_42/boost/mpl/aux_/joint_iter.hpp"
template< typename T1 , typename T2 , typename T3 , typename Tag > struct lambda< joint_iter< T1 , T2 , T3 > , Tag , int_<3> > { typedef false_ is_le; typedef joint_iter< T1 , T2 , T3 > result_; typedef result_ type; };

}}
# 18 "/usr/include/boost-1_42/boost/mpl/joint_view.hpp" 2





namespace boost { namespace mpl {

namespace aux {
struct joint_view_tag;
}

template<>
struct size_impl< aux::joint_view_tag >
{
    template < typename JointView > struct apply
      : plus<
            size<typename JointView::sequence1_>
          , size<typename JointView::sequence2_>
          >
    {};
};

template<
      typename Sequence1_ = na
    , typename Sequence2_ = na
    >
struct joint_view
{
    typedef typename mpl::begin<Sequence1_>::type first1_;
    typedef typename mpl::end<Sequence1_>::type last1_;
    typedef typename mpl::begin<Sequence2_>::type first2_;
    typedef typename mpl::end<Sequence2_>::type last2_;


    typedef Sequence1_ sequence1_;
    typedef Sequence2_ sequence2_;

    typedef joint_view type;
    typedef aux::joint_view_tag tag;
    typedef joint_iter<first1_,last1_,first2_> begin;
    typedef joint_iter<last1_,last1_,last2_> end;
};

template<> struct joint_view< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : joint_view< T1 , T2 > { }; }; template< typename Tag > struct lambda< joint_view< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef joint_view< na , na > result_; typedef joint_view< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< joint_view< T1 , T2 > > : int_<2> { }; template<> struct template_arity< joint_view< na , na > > : int_<-1> { }; }

}}
# 28 "/usr/include/boost-1_42/boost/python/init.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/back.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/back.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/back_impl.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/back_impl.hpp"
namespace boost { namespace mpl {





template< typename Tag >
struct back_impl
{
    template< typename Sequence > struct apply
    {
        typedef typename end<Sequence>::type end_;
        typedef typename prior<end_>::type last_;
        typedef typename deref<last_>::type type;
    };
};

 template<> struct back_impl<non_sequence_tag> {};

}}
# 19 "/usr/include/boost-1_42/boost/mpl/back.hpp" 2




namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct back
    : back_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct back< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : back< T1 > { }; }; template< typename Tag > struct lambda< back< na > , Tag , int_<-1> > { typedef false_ is_le; typedef back< na > result_; typedef back< na > type; }; namespace aux { template< typename T1 > struct template_arity< back< T1 > > : int_<1> { }; template<> struct template_arity< back< na > > : int_<-1> { }; }

}}
# 29 "/usr/include/boost-1_42/boost/python/init.hpp" 2
# 55 "/usr/include/boost-1_42/boost/python/init.hpp"
namespace boost { namespace python {

template < class T0 = mpl::void_ , class T1 = mpl::void_ , class T2 = mpl::void_ , class T3 = mpl::void_ , class T4 = mpl::void_ , class T5 = mpl::void_ , class T6 = mpl::void_ , class T7 = mpl::void_ , class T8 = mpl::void_ , class T9 = mpl::void_ , class T10 = mpl::void_ , class T11 = mpl::void_ , class T12 = mpl::void_ , class T13 = mpl::void_ , class T14 = mpl::void_ >
class init;


template < class T0 = mpl::void_ , class T1 = mpl::void_ , class T2 = mpl::void_ , class T3 = mpl::void_ , class T4 = mpl::void_ , class T5 = mpl::void_ , class T6 = mpl::void_ , class T7 = mpl::void_ , class T8 = mpl::void_ , class T9 = mpl::void_ , class T10 = mpl::void_ , class T11 = mpl::void_ , class T12 = mpl::void_ , class T13 = mpl::void_ , class T14 = mpl::void_ >
struct optional;

namespace detail
{
  namespace error
  {
    template <int keywords, int init_args>
    struct more_keywords_than_init_arguments
    {
        typedef char too_many_keywords[init_args - keywords >= 0 ? 1 : -1];
    };
  }
# 101 "/usr/include/boost-1_42/boost/python/init.hpp"
    template <class T>
    struct is_optional
      : mpl::false_
    {};

    template < class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
    struct is_optional<optional< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> >
      : mpl::true_
    {};



  template <int NDefaults>
  struct define_class_init_helper;

}

template <class DerivedT>
struct init_base : def_visitor<DerivedT>
{
    init_base(char const* doc_, detail::keyword_range const& keywords_)
        : m_doc(doc_), m_keywords(keywords_)
    {}

    init_base(char const* doc_)
        : m_doc(doc_)
    {}

    DerivedT const& derived() const
    {
        return *static_cast<DerivedT const*>(this);
    }

    char const* doc_string() const
    {
        return m_doc;
    }

    detail::keyword_range const& keywords() const
    {
        return m_keywords;
    }

    static default_call_policies call_policies()
    {
        return default_call_policies();
    }

 private:
# 164 "/usr/include/boost-1_42/boost/python/init.hpp"
    template <class classT>
    void visit(classT& cl) const
    {
        typedef typename DerivedT::signature signature;
        typedef typename DerivedT::n_arguments n_arguments;
        typedef typename DerivedT::n_defaults n_defaults;

        detail::define_class_init_helper<n_defaults::value>::apply(
            cl
          , derived().call_policies()
          , signature()
          , n_arguments()
          , derived().doc_string()
          , derived().keywords());
    }

    friend class python::def_visitor_access;

 private:
    char const* m_doc;
    detail::keyword_range m_keywords;
};

template <class CallPoliciesT, class InitT>
class init_with_call_policies
    : public init_base<init_with_call_policies<CallPoliciesT, InitT> >
{
    typedef init_base<init_with_call_policies<CallPoliciesT, InitT> > base;
 public:
    typedef typename InitT::n_arguments n_arguments;
    typedef typename InitT::n_defaults n_defaults;
    typedef typename InitT::signature signature;

    init_with_call_policies(
        CallPoliciesT const& policies_
        , char const* doc_
        , detail::keyword_range const& keywords
        )
        : base(doc_, keywords)
        , m_policies(policies_)
    {}

    CallPoliciesT const& call_policies() const
    {
        return this->m_policies;
    }

 private:
    CallPoliciesT m_policies;
};




namespace detail
{
  template <class S>
  struct drop1
    : mpl::iterator_range<
          typename mpl::begin<S>::type
        , typename mpl::prior<
              typename mpl::end<S>::type
          >::type
      >
  {};
}

template < class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
class init : public init_base<init< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> >
{
    typedef init_base<init< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> > base;
 public:
    typedef init< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> self_t;

    init(char const* doc_ = 0)
        : base(doc_)
    {
    }

    template <std::size_t N>
    init(char const* doc_, detail::keywords<N> const& kw)
        : base(doc_, kw.range())
    {
        typedef typename detail::error::more_keywords_than_init_arguments<
            N, n_arguments::value + 1
            >::too_many_keywords assertion;
    }

    template <std::size_t N>
    init(detail::keywords<N> const& kw, char const* doc_ = 0)
        : base(doc_, kw.range())
    {
        typedef typename detail::error::more_keywords_than_init_arguments<
            N, n_arguments::value + 1
            >::too_many_keywords assertion;
    }

    template <class CallPoliciesT>
    init_with_call_policies<CallPoliciesT, self_t>
    operator[](CallPoliciesT const& policies) const
    {
        return init_with_call_policies<CallPoliciesT, self_t>(
            policies, this->doc_string(), this->keywords());
    }

    typedef detail::type_list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> signature_;

    typedef detail::is_optional<
        typename mpl::eval_if<
            mpl::empty<signature_>
          , mpl::false_
          , mpl::back<signature_>
        >::type
    > back_is_optional;

    typedef typename mpl::eval_if<
        back_is_optional
      , mpl::back<signature_>
      , mpl::vector0<>
    >::type optional_args;

    typedef typename mpl::eval_if<
        back_is_optional
      , mpl::if_<
            mpl::empty<optional_args>
          , detail::drop1<signature_>
          , mpl::joint_view<
                detail::drop1<signature_>
              , optional_args
            >
        >
      , signature_
    >::type signature;




    typedef mpl::size<optional_args> n_defaults;
    typedef mpl::size<signature> n_arguments;
};
# 312 "/usr/include/boost-1_42/boost/python/init.hpp"
template < class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct optional
    : detail::type_list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
{
};

namespace detail
{
  template <class ClassT, class CallPoliciesT, class Signature, class NArgs>
  inline void def_init_aux(
      ClassT& cl
      , Signature const&
      , NArgs
      , CallPoliciesT const& policies
      , char const* doc
      , detail::keyword_range const& keywords_
      )
  {
      cl.def(
          "__init__"
        , detail::make_keyword_range_constructor<Signature,NArgs>(
              policies
            , keywords_
            , (typename ClassT::metadata::holder*)0
          )
        , doc
      );
  }
# 353 "/usr/include/boost-1_42/boost/python/init.hpp"
  template <int NDefaults>
  struct define_class_init_helper
  {

      template <class ClassT, class CallPoliciesT, class Signature, class NArgs>
      static void apply(
          ClassT& cl
          , CallPoliciesT const& policies
          , Signature const& args
          , NArgs
          , char const* doc
          , detail::keyword_range keywords)
      {
          detail::def_init_aux(cl, args, NArgs(), policies, doc, keywords);

          if (keywords.second > keywords.first)
              --keywords.second;

          typedef typename mpl::prior<NArgs>::type next_nargs;
          define_class_init_helper<NDefaults-1>::apply(
              cl, policies, Signature(), next_nargs(), doc, keywords);
      }
  };
# 387 "/usr/include/boost-1_42/boost/python/init.hpp"
  template <>
  struct define_class_init_helper<0> {

      template <class ClassT, class CallPoliciesT, class Signature, class NArgs>
      static void apply(
          ClassT& cl
        , CallPoliciesT const& policies
        , Signature const& args
        , NArgs
        , char const* doc
        , detail::keyword_range const& keywords)
      {
          detail::def_init_aux(cl, args, NArgs(), policies, doc, keywords);
      }
  };
}

}}
# 21 "/usr/include/boost-1_42/boost/python/class.hpp" 2


# 1 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 1





# 1 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_from_python.hpp" 1
# 18 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_from_python.hpp"
namespace boost { namespace python { namespace converter {

template <class T>
struct shared_ptr_from_python
{
    shared_ptr_from_python()
    {
        converter::registry::insert(&convertible, &construct, type_id<shared_ptr<T> >()

                      , &converter::expected_from_python_type_direct<T>::get_pytype

                      );
    }

 private:
    static void* convertible(PyObject* p)
    {
        if (p == (&_Py_NoneStruct))
            return p;

        return converter::get_lvalue_from_python(p, registered<T>::converters);
    }

    static void construct(PyObject* source, rvalue_from_python_stage1_data* data)
    {
        void* const storage = ((converter::rvalue_from_python_storage<shared_ptr<T> >*)data)->storage.bytes;

        if (data->convertible == source)
            new (storage) shared_ptr<T>();
        else
        {
            boost::shared_ptr<void> hold_convertible_ref_count(
              (void*)0, shared_ptr_deleter(handle<>(borrowed(source))) );

            new (storage) shared_ptr<T>(
                hold_convertible_ref_count,
                static_cast<T*>(data->convertible));
        }

        data->convertible = storage;
    }
};

}}}
# 7 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/object/inheritance.hpp" 1
# 15 "/usr/include/boost-1_42/boost/python/object/inheritance.hpp"
namespace boost { namespace python { namespace objects {

typedef type_info class_id;
using python::type_id;


typedef std::pair<void*,class_id> dynamic_id_t;
typedef dynamic_id_t (*dynamic_id_function)(void*);

 void register_dynamic_id_aux(
    class_id static_id, dynamic_id_function get_dynamic_id);

 void add_cast(
    class_id src_t, class_id dst_t, void* (*cast)(void*), bool is_downcast);
# 37 "/usr/include/boost-1_42/boost/python/object/inheritance.hpp"
template <class T>
struct polymorphic_id_generator
{
    static dynamic_id_t execute(void* p_)
    {
        T* p = static_cast<T*>(p_);
        return std::make_pair(dynamic_cast<void*>(p), class_id(typeid(*p)));
    }
};


template <class T>
struct non_polymorphic_id_generator
{
    static dynamic_id_t execute(void* p_)
    {
        return std::make_pair(p_, python::type_id<T>());
    }
};


template <class T>
struct dynamic_id_generator
  : mpl::if_<
        boost::is_polymorphic<T>
        , boost::python::objects::polymorphic_id_generator<T>
        , boost::python::objects::non_polymorphic_id_generator<T>
    >
{};



template <class T>
void register_dynamic_id(T* = 0)
{
    typedef typename dynamic_id_generator<T>::type generator;
    register_dynamic_id_aux(
        python::type_id<T>(), &generator::execute);
}







template <class Source, class Target>
struct dynamic_cast_generator
{
    static void* execute(void* source)
    {
        return dynamic_cast<Target*>(
            static_cast<Source*>(source));
    }

};

template <class Source, class Target>
struct implicit_cast_generator
{
    static void* execute(void* source)
    {
        Target* result = static_cast<Source*>(source);
        return result;
    }
};

template <class Source, class Target>
struct cast_generator
  : mpl::if_<
        is_base_and_derived<Target,Source>
      , implicit_cast_generator<Source,Target>
      , dynamic_cast_generator<Source,Target>
    >
{
};

template <class Source, class Target>
inline void register_conversion(
    bool is_downcast = ::boost::is_base_and_derived<Source,Target>::value

    , Source* = 0, Target* = 0)
{
    typedef typename cast_generator<Source,Target>::type generator;

    add_cast(
        python::type_id<Source>()
      , python::type_id<Target>()
      , &generator::execute
      , is_downcast
    );
}

}}}
# 9 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/class_wrapper.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/to_python_converter.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/to_python_converter.hpp"
# 1 "/usr/include/boost-1_42/boost/python/converter/as_to_python_function.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/converter/as_to_python_function.hpp"
namespace boost { namespace python { namespace converter {



template <class T, class ToPython>
struct as_to_python_function
{




    template <class U>
    static void convert_function_must_take_value_or_const_reference(U(*)(T), int, T* = 0) {}
    template <class U>
    static void convert_function_must_take_value_or_const_reference(U(*)(T const&), long ...) {}

    static PyObject* convert(void const* x)
    {
        convert_function_must_take_value_or_const_reference(&ToPython::convert, 1L);
# 40 "/usr/include/boost-1_42/boost/python/converter/as_to_python_function.hpp"
        return ToPython::convert(*const_cast<T*>(static_cast<T const*>(x)));
    }

    static PyTypeObject const * get_pytype() { return ToPython::get_pytype(); }

};

}}}
# 12 "/usr/include/boost-1_42/boost/python/to_python_converter.hpp" 2





namespace boost { namespace python {
# 47 "/usr/include/boost-1_42/boost/python/to_python_converter.hpp"
template < class T, class Conversion, bool has_get_pytype=false >
struct to_python_converter
{





    typedef boost::mpl::bool_<has_get_pytype> HasGetPytype;


    static PyTypeObject const* get_pytype_1(boost::mpl::true_ *)
    {
        return Conversion::get_pytype();
    }

    static PyTypeObject const* get_pytype_1(boost::mpl::false_ *)
    {
        return 0;
    }
    static PyTypeObject const* get_pytype_impl()
    {
        return get_pytype_1((HasGetPytype*)0);
    }


    to_python_converter();
};





template <class T, class Conversion ,bool has_get_pytype>
to_python_converter<T,Conversion, has_get_pytype>::to_python_converter()
{
    typedef converter::as_to_python_function<
        T, Conversion
        > normalized;

    converter::registry::insert(
        &normalized::convert
        , type_id<T>()

        , &get_pytype_impl

        );
}

}}
# 9 "/usr/include/boost-1_42/boost/python/object/class_wrapper.hpp" 2





namespace boost { namespace python { namespace objects {
# 23 "/usr/include/boost-1_42/boost/python/object/class_wrapper.hpp"
template <class Src, class MakeInstance>
struct class_cref_wrapper
    : to_python_converter<Src,class_cref_wrapper<Src,MakeInstance> ,true>
{
    static PyObject* convert(Src const& x)
    {
        return MakeInstance::execute(boost::ref(x));
    }

    static PyTypeObject const *get_pytype() { return converter::registered_pytype_direct<Src>::get_pytype(); }

};

template <class Src, class MakeInstance>
struct class_value_wrapper
    : to_python_converter<Src,class_value_wrapper<Src,MakeInstance> ,true>
{
    static PyObject* convert(Src x)
    {
        return MakeInstance::execute(x);
    }

    static PyTypeObject const *get_pytype() { return MakeInstance::get_pytype(); }

};

}}}
# 10 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/value_holder_fwd.hpp" 1







namespace boost { namespace python { namespace objects {

struct no_back_reference;

template <class CallbackType = no_back_reference> struct value_holder_generator;

}}}
# 12 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 2



# 1 "/usr/include/boost-1_42/boost/python/wrapper.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/override.hpp"
# 1 "/usr/include/boost-1_42/boost/python/extract.hpp" 1
# 32 "/usr/include/boost-1_42/boost/python/extract.hpp"
namespace boost { namespace python {

namespace api
{
  class object;
}

namespace converter
{
  template <class Ptr>
  struct extract_pointer
  {
      typedef Ptr result_type;
      extract_pointer(PyObject*);

      bool check() const;
      Ptr operator()() const;

   private:
      PyObject* m_source;
      void* m_result;
  };

  template <class Ref>
  struct extract_reference
  {
      typedef Ref result_type;
      extract_reference(PyObject*);

      bool check() const;
      Ref operator()() const;

   private:
      PyObject* m_source;
      void* m_result;
  };

  template <class T>
  struct extract_rvalue : private noncopyable
  {
      typedef typename mpl::if_<
          python::detail::copy_ctor_mutates_rhs<T>
        , T&
        , typename call_traits<T>::param_type
      >::type result_type;

      extract_rvalue(PyObject*);

      bool check() const;
      result_type operator()() const;
   private:
      PyObject* m_source;
      mutable rvalue_from_python_data<T> m_data;
  };

  template <class T>
  struct extract_object_manager
  {
      typedef T result_type;
      extract_object_manager(PyObject*);

      bool check() const;
      result_type operator()() const;
   private:
      PyObject* m_source;
  };

  template <class T>
  struct select_extract
  {
      static const bool obj_mgr = is_object_manager<T>::value
                                                      ;

      static const bool ptr = is_pointer<T>::value
                                           ;

      static const bool ref = is_reference<T>::value
                                             ;

      typedef typename mpl::if_c<
          obj_mgr
          , extract_object_manager<T>
          , typename mpl::if_c<
              ptr
              , extract_pointer<T>
              , typename mpl::if_c<
                  ref
                  , extract_reference<T>
                  , extract_rvalue<T>
                >::type
            >::type
         >::type type;
  };
}

template <class T>
struct extract
    : converter::select_extract<T>::type
{
 private:
    typedef typename converter::select_extract<T>::type base;
 public:
    typedef typename base::result_type result_type;

    operator result_type() const
    {
        return (*this)();
    }

    extract(PyObject*);
    extract(api::object const&);
};




template <class T>
inline extract<T>::extract(PyObject* o)
    : base(o)
{
}

template <class T>
inline extract<T>::extract(api::object const& o)
    : base(o.ptr())
{
}

namespace converter
{
  template <class T>
  inline extract_rvalue<T>::extract_rvalue(PyObject* x)
      : m_source(x)
      , m_data(
          (rvalue_from_python_stage1)(x, registered<T>::converters)
          )
  {
  }

  template <class T>
  inline bool
  extract_rvalue<T>::check() const
  {
      return m_data.stage1.convertible;
  }

  template <class T>
  inline typename extract_rvalue<T>::result_type
  extract_rvalue<T>::operator()() const
  {
      return *(T*)(

          m_data.stage1.convertible == m_data.storage.bytes
             ? m_data.storage.bytes
             : (rvalue_from_python_stage2)(m_source, m_data.stage1, registered<T>::converters)
          );
  }

  template <class Ref>
  inline extract_reference<Ref>::extract_reference(PyObject* obj)
      : m_source(obj)
      , m_result(
          (get_lvalue_from_python)(obj, registered<Ref>::converters)
          )
  {
  }

  template <class Ref>
  inline bool extract_reference<Ref>::check() const
  {
      return m_result != 0;
  }

  template <class Ref>
  inline Ref extract_reference<Ref>::operator()() const
  {
      if (m_result == 0)
          (throw_no_reference_from_python)(m_source, registered<Ref>::converters);

      return python::detail::void_ptr_to_reference(m_result, (Ref(*)())0);
  }

  template <class Ptr>
  inline extract_pointer<Ptr>::extract_pointer(PyObject* obj)
      : m_source(obj)
      , m_result(
          obj == (&_Py_NoneStruct) ? 0 : (get_lvalue_from_python)(obj, registered_pointee<Ptr>::converters)
          )
  {
  }

  template <class Ptr>
  inline bool extract_pointer<Ptr>::check() const
  {
      return m_source == (&_Py_NoneStruct) || m_result != 0;
  }

  template <class Ptr>
  inline Ptr extract_pointer<Ptr>::operator()() const
  {
      if (m_result == 0 && m_source != (&_Py_NoneStruct))
          (throw_no_pointer_from_python)(m_source, registered_pointee<Ptr>::converters);

      return Ptr(m_result);
  }

  template <class T>
  inline extract_object_manager<T>::extract_object_manager(PyObject* obj)
      : m_source(obj)
  {
  }

  template <class T>
  inline bool extract_object_manager<T>::check() const
  {
      return object_manager_traits<T>::check(m_source);
  }

  template <class T>
  inline T extract_object_manager<T>::operator()() const
  {
      return T(
          object_manager_traits<T>::adopt(python::incref(m_source))
          );
  }
}

}}
# 14 "/usr/include/boost-1_42/boost/python/override.hpp" 2
# 24 "/usr/include/boost-1_42/boost/python/override.hpp"
namespace boost { namespace python {

class override;

namespace detail
{
  class wrapper_base;


  class method_result
  {
   private:
      friend class boost::python::override;
      explicit method_result(PyObject* x)
        : m_obj(x)
      {}

   public:
      template <class T>
      operator T()
      {
          converter::return_from_python<T> converter;
          return converter(m_obj.release());
      }
# 62 "/usr/include/boost-1_42/boost/python/override.hpp"
      template <class T>
      operator T&() const
      {
          converter::return_from_python<T&> converter;
          return converter(const_cast<handle<>&>(m_obj).release());
      }


      template <class T>
      T as(type<T>* = 0)
      {
          converter::return_from_python<T> converter;
          return converter(m_obj.release());
      }

      template <class T>
      T unchecked(type<T>* = 0)
      {
          return extract<T>(m_obj)();
      }
   private:
      mutable handle<> m_obj;
  };
}

class override : public object
{
 private:
    friend class detail::wrapper_base;
    override(handle<> x)
      : object(x)
    {}

 public:
    detail::method_result
    operator()() const
    {
        detail::method_result x(
            PyEval_CallFunction(
                this->ptr()
              , const_cast<char*>("()")
            ));
        return x;
    }





# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 52 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0
    >
detail::method_result
operator()( A0 const& a0 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" ")")
            , converter::arg_to_python<A0>(a0).get()
        ));
    return x;
}
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get()
        ));
    return x;
}
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get()
        ));
    return x;
}
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get()
        ));
    return x;
}
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get()
        ));
    return x;
}
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4 , class A5
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get()
        ));
    return x;
}
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get()
        ));
    return x;
}
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get()
        ));
    return x;
}
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get()
        ));
    return x;
}
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get()
        ));
    return x;
}
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get()
        ));
    return x;
}
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get()
        ));
    return x;
}
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get()
        ));
    return x;
}
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get()
        ));
    return x;
}
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
# 123 "/usr/include/boost-1_42/boost/python/override.hpp"




template <
    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14
    >
detail::method_result
operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 ) const
{
    detail::method_result x(
        PyEval_CallFunction(
            this->ptr()
          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get() , converter::arg_to_python<A14>(a14).get()
        ));
    return x;
}
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 112 "/usr/include/boost-1_42/boost/python/override.hpp" 2


};

}}
# 9 "/usr/include/boost-1_42/boost/python/wrapper.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/detail/sfinae.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/wrapper.hpp" 2

namespace boost { namespace python {

template <class T>
class wrapper : public detail::wrapper_base
{
 public:

    typedef T _wrapper_wrapped_type_;

 protected:
    override get_override(char const* name) const
    {
        typedef detail::wrapper_base base;
        converter::registration const& r
            = converter::registered<T>::converters;
        PyTypeObject* type = r.get_class_object();

        return this->base::get_override(name, type);
    }
};

}}
# 16 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 2
# 34 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
namespace boost { namespace python { namespace objects {







template <class Value>
struct value_holder : instance_holder
{
    typedef Value held_type;
    typedef Value value_type;



# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"







    value_holder(
      PyObject* self )
        : m_held(
           
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0>

    value_holder(
      PyObject* self , A0 a0)
        : m_held(
            objects::do_unforward(a0,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1>

    value_holder(
      PyObject* self , A0 a0 , A1 a1)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>

    value_holder(
      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13 , A14 a14)
        : m_held(
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0) , objects::do_unforward(a14,0)
            )
    {
        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
    }
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 51 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 2

 private:
    void* holds(type_info, bool null_ptr_only);

    template <class T>
    inline void* holds_wrapped(type_info dst_t, wrapper<T>*,T* p)
    {
        return python::type_id<T>() == dst_t ? p : 0;
    }

    inline void* holds_wrapped(type_info, ...)
    {
        return 0;
    }
 private:
    Value m_held;
};

template <class Value, class Held>
struct value_holder_back_reference : instance_holder
{
    typedef Held held_type;
    typedef Value value_type;



# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"







    value_holder_back_reference(
        PyObject* p )
        : m_held(
            p
           
            )
    {
    }
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0>

    value_holder_back_reference(
        PyObject* p , A0 a0)
        : m_held(
            p ,
            objects::do_unforward(a0,0)
            )
    {
    }
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0)
            )
    {
    }
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0)
            )
    {
    }
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0)
            )
    {
    }
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0)
            )
    {
    }
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0)
            )
    {
    }
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0)
            )
    {
    }
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0)
            )
    {
    }
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0)
            )
    {
    }
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0)
            )
    {
    }
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0)
            )
    {
    }
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0)
            )
    {
    }
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0)
            )
    {
    }
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0)
            )
    {
    }
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"





    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>

    value_holder_back_reference(
        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13 , A14 a14)
        : m_held(
            p ,
            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0) , objects::do_unforward(a14,0)
            )
    {
    }
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 78 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 2

private:
    void* holds(type_info, bool null_ptr_only);

 private:
    Held m_held;
};



template <class Value>
void* value_holder<Value>::holds(type_info dst_t, bool )
{
    if (void* wrapped = holds_wrapped(dst_t, boost::addressof(m_held), boost::addressof(m_held)))
        return wrapped;

    type_info src_t = python::type_id<Value>();
    return src_t == dst_t ? boost::addressof(m_held)
        : find_static_type(boost::addressof(m_held), src_t, dst_t);
}

template <class Value, class Held>
void* value_holder_back_reference<Value,Held>::holds(
    type_info dst_t, bool )
{
    type_info src_t = python::type_id<Value>();
    Value* x = &m_held;

    if (dst_t == src_t)
        return x;
    else if (dst_t == python::type_id<Held>())
        return &m_held;
    else
        return find_static_type(x, src_t, dst_t);
}

}}}
# 12 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2





# 1 "/usr/include/boost-1_42/boost/python/has_back_reference.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/has_back_reference.hpp"
namespace boost { namespace python {



template <class T>
struct has_back_reference
  : mpl::false_
{
};


}}
# 19 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
# 30 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/for_each.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/for_each.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/is_sequence.hpp" 1
# 40 "/usr/include/boost-1_42/boost/mpl/is_sequence.hpp"
namespace boost { namespace mpl {
# 90 "/usr/include/boost-1_42/boost/mpl/is_sequence.hpp"
template<
      typename T = na
    >
struct is_sequence
    : not_< is_same< typename begin<T>::type, void_ > >
{
   
};
# 108 "/usr/include/boost-1_42/boost/mpl/is_sequence.hpp"
template<> struct is_sequence< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_sequence< T1 > { }; }; template< typename Tag > struct lambda< is_sequence< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_sequence< na > result_; typedef is_sequence< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_sequence< T1 > > : int_<1> { }; template<> struct template_arity< is_sequence< na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost-1_42/boost/mpl/for_each.hpp" 2

# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/for_each.hpp" 2





# 1 "/usr/include/boost-1_42/boost/mpl/aux_/unwrap.hpp" 1
# 20 "/usr/include/boost-1_42/boost/mpl/aux_/unwrap.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename F >
inline
F& unwrap(F& f, long)
{
    return f;
}

template< typename F >
inline
F&
unwrap(reference_wrapper<F>& f, int)
{
    return f;
}

template< typename F >
inline
F&
unwrap(reference_wrapper<F> const& f, int)
{
    return f;
}

}}}
# 26 "/usr/include/boost-1_42/boost/mpl/for_each.hpp" 2


# 1 "/usr/include/boost-1_42/boost/utility/value_init.hpp" 1
# 22 "/usr/include/boost-1_42/boost/utility/value_init.hpp"
# 1 "/usr/include/boost-1_42/boost/aligned_storage.hpp" 1
# 16 "/usr/include/boost-1_42/boost/aligned_storage.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 17 "/usr/include/boost-1_42/boost/aligned_storage.hpp" 2
# 27 "/usr/include/boost-1_42/boost/aligned_storage.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 28 "/usr/include/boost-1_42/boost/aligned_storage.hpp" 2

namespace boost {

namespace detail { namespace aligned_storage {

static const std::size_t alignment_of_max_align = ::boost::alignment_of<max_align>::value


     ;




template <
      std::size_t size_
    , std::size_t alignment_
>
struct aligned_storage_imp
{
    union data_t
    {
        char buf[size_];

        typename mpl::eval_if_c<
              alignment_ == std::size_t(-1)
            , mpl::identity<detail::max_align>
            , type_with_alignment<alignment_>
            >::type align_;
    } data_;
    void* address() const { return const_cast<aligned_storage_imp*>(this); }
};

template< std::size_t alignment_ >
struct aligned_storage_imp<0u,alignment_>
{

    void* address() const { return 0; }
};

}}

template <
      std::size_t size_
    , std::size_t alignment_ = std::size_t(-1)
>
class aligned_storage :

   private



   detail::aligned_storage::aligned_storage_imp<size_, alignment_>
{

public:

    typedef detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;

    static const std::size_t size = size_


         ;
    static const std::size_t alignment = ( alignment_ == std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align : alignment_ )






         ;






private:

    aligned_storage(const aligned_storage&);
    aligned_storage& operator=(const aligned_storage&);
# 118 "/usr/include/boost-1_42/boost/aligned_storage.hpp"
public:

    aligned_storage()
    {
    }

    ~aligned_storage()
    {
    }

public:

    void* address()
    {
        return static_cast<type*>(this)->address();
    }



    const void* address() const
    {
        return static_cast<const type*>(this)->address();
    }







};
# 168 "/usr/include/boost-1_42/boost/aligned_storage.hpp"
template <std::size_t size_, std::size_t alignment_>
struct is_pod<boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
   : ::boost::integral_constant<bool,true>
{
   
};



}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 180 "/usr/include/boost-1_42/boost/aligned_storage.hpp" 2
# 23 "/usr/include/boost-1_42/boost/utility/value_init.hpp" 2




# 1 "/usr/include/boost-1_42/boost/swap.hpp" 1
# 10 "/usr/include/boost-1_42/boost/swap.hpp"
# 1 "/usr/include/boost-1_42/boost/utility/swap.hpp" 1
# 25 "/usr/include/boost-1_42/boost/utility/swap.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 26 "/usr/include/boost-1_42/boost/utility/swap.hpp" 2

namespace boost_swap_impl
{
  template<class T>
  void swap_impl(T& left, T& right)
  {
    using namespace std;
    swap(left,right);
  }

  template<class T, std::size_t N>
  void swap_impl(T (& left)[N], T (& right)[N])
  {
    for (std::size_t i = 0; i < N; ++i)
    {
      ::boost_swap_impl::swap_impl(left[i], right[i]);
    }
  }
}

namespace boost
{
  template<class T1, class T2>
  void swap(T1& left, T2& right)
  {
    ::boost_swap_impl::swap_impl(left, right);
  }
}
# 11 "/usr/include/boost-1_42/boost/swap.hpp" 2
# 28 "/usr/include/boost-1_42/boost/utility/value_init.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 2 3
# 29 "/usr/include/boost-1_42/boost/utility/value_init.hpp" 2


namespace boost {

template<class T>
class value_initialized
{
  private :
    struct wrapper
    {

      typename

      remove_const<T>::type data;
    };

    mutable

      typename

      aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;

    wrapper * wrapper_address() const
    {
      return static_cast<wrapper *>( static_cast<void*>(&x));
    }

  public :

    value_initialized()
    {
      std::memset(&x, 0, sizeof(x));
# 70 "/usr/include/boost-1_42/boost/utility/value_init.hpp"
      new (wrapper_address()) wrapper();



    }

    value_initialized(value_initialized const & arg)
    {
      new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address())));
    }

    value_initialized & operator=(value_initialized const & arg)
    {

      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((! is_const<T>::value) == 0 ? false : true) >)> boost_static_assert_typedef_84;
      *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
      return *this;
    }

    ~value_initialized()
    {
      wrapper_address()->wrapper::~wrapper();
    }

    T const & data() const
    {
      return wrapper_address()->data;
    }

    T& data()
    {
      return wrapper_address()->data;
    }

    void swap(value_initialized & arg)
    {
      ::boost::swap( this->data(), arg.data() );
    }

    operator T const &() const { return this->data(); }

    operator T&() { return this->data(); }

} ;



template<class T>
T const& get ( value_initialized<T> const& x )
{
  return x.data() ;
}
template<class T>
T& get ( value_initialized<T>& x )
{
  return x.data() ;
}

template<class T>
void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
{
  lhs.swap(rhs) ;
}


class initialized_value_t
{
  public :

    template <class T> operator T() const
    {
      return get( value_initialized<T>() );
    }
};

initialized_value_t const initialized_value = {} ;


}
# 29 "/usr/include/boost-1_42/boost/mpl/for_each.hpp" 2

namespace boost { namespace mpl {

namespace aux {

template< bool done = true >
struct for_each_impl
{
    template<
          typename Iterator
        , typename LastIterator
        , typename TransformFunc
        , typename F
        >
    static void execute(
          Iterator*
        , LastIterator*
        , TransformFunc*
        , F
        )
    {
    }
};

template<>
struct for_each_impl<false>
{
    template<
          typename Iterator
        , typename LastIterator
        , typename TransformFunc
        , typename F
        >
    static void execute(
          Iterator*
        , LastIterator*
        , TransformFunc*
        , F f
        )
    {
        typedef typename deref<Iterator>::type item;
        typedef typename apply1<TransformFunc,item>::type arg;



        value_initialized<arg> x;
        aux::unwrap(f, 0)(boost::get(x));

        typedef typename mpl::next<Iterator>::type iter;
        for_each_impl<boost::is_same<iter,LastIterator>::value>
            ::execute( static_cast<iter*>(0), static_cast<LastIterator*>(0), static_cast<TransformFunc*>(0), f);
    }
};

}



template<
      typename Sequence
    , typename TransformOp
    , typename F
    >
inline
void for_each(F f, Sequence* = 0, TransformOp* = 0)
{
    enum { mpl_assertion_in_line_95 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) ( is_sequence<Sequence> ))0, 1 ) ) ) };

    typedef typename begin<Sequence>::type first;
    typedef typename end<Sequence>::type last;

    aux::for_each_impl< boost::is_same<first,last>::value >
        ::execute(static_cast<first*>(0), static_cast<last*>(0), static_cast<TransformOp*>(0), f);
}

template<
      typename Sequence
    , typename F
    >
inline
void for_each(F f, Sequence* = 0)
{
    for_each<Sequence, identity<> >(f);
}

}}
# 31 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 1
# 32 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/single_view.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/single_view.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/single_element_iter.hpp" 1
# 27 "/usr/include/boost-1_42/boost/mpl/aux_/single_element_iter.hpp"
namespace boost { namespace mpl {



namespace aux {

template< typename T, int is_last_ >
struct sel_iter;

template< typename T >
struct sel_iter<T,0>
{
    typedef random_access_iterator_tag category;
    typedef sel_iter<T,1> next;
    typedef T type;
};

template< typename T >
struct sel_iter<T,1>
{
    typedef random_access_iterator_tag category;
    typedef sel_iter<T,0> prior;
};

}

template< typename T, int is_last_, typename Distance >
struct advance< aux::sel_iter<T,is_last_>,Distance>
{
    typedef aux::sel_iter<
          T
        , ( is_last_ + Distance::value )
        > type;
};

template<
      typename T
    , int l1
    , int l2
    >
struct distance< aux::sel_iter<T,l1>, aux::sel_iter<T,l2> >
    : int_<( l2 - l1 )>
{
};
# 116 "/usr/include/boost-1_42/boost/mpl/aux_/single_element_iter.hpp"
}}
# 18 "/usr/include/boost-1_42/boost/mpl/single_view.hpp" 2



namespace boost { namespace mpl {

template<
      typename T = na
    >
struct single_view
    : iterator_range<
          aux::sel_iter<T,0>
        , aux::sel_iter<T,1>
        >
{
};

template<> struct single_view< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : single_view< T1 > { }; }; template< typename Tag > struct lambda< single_view< na > , Tag , int_<-1> > { typedef false_ is_le; typedef single_view< na > result_; typedef single_view< na > type; }; namespace aux { template< typename T1 > struct template_arity< single_view< T1 > > : int_<1> { }; template<> struct template_arity< single_view< na > > : int_<-1> { }; }

}}
# 33 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
# 42 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp"
namespace boost { namespace python { namespace objects {


void copy_class_object(type_info const& src, type_info const& dst);




template <class Derived>
struct register_base_of
{
    template <class Base>
    inline void operator()(Base*) const
    {

        enum { mpl_assertion_in_line_57 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_same<Base,Derived>))0, 1 ) ) ) };





        register_dynamic_id<Base>();


        register_conversion<Derived,Base>(false);


        this->register_downcast((Base*)0, is_polymorphic<Base>());
    }

 private:
    static inline void register_downcast(void*, mpl::false_) {}

    template <class Base>
    static inline void register_downcast(Base*, mpl::true_)
    {
        register_conversion<Base, Derived>(true);
    }

};





template <class T, class Bases>
inline void register_shared_ptr_from_python_and_casts(T*, Bases)
{

    python::detail::force_instantiate(converter::shared_ptr_from_python<T>());





    register_dynamic_id<T>();
    mpl::for_each(register_base_of<T>(), (Bases*)0, (add_pointer<mpl::_>*)0);
}




template <class T, class Prev>
struct select_held_type
  : mpl::if_<
        mpl::or_<
            python::detail::specifies_bases<T>
          , is_same<T,noncopyable>
        >
      , Prev
      , T
    >
{
};

template <
    class T
  , class X1
  , class X2
  , class X3
>
struct class_metadata
{







    typedef typename select_held_type<
        X1
      , typename select_held_type<
            X2
          , typename select_held_type<
                X3
              , python::detail::not_specified
            >::type
        >::type
    >::type held_type_arg;


    typedef typename python::detail::select_bases<
        X1
      , typename python::detail::select_bases<
            X2
          , typename python::detail::select_bases<
                X3
              , python::bases<>
            >::type
        >::type
    >::type bases;

    typedef mpl::or_<
        is_same<X1,noncopyable>
      , is_same<X2,noncopyable>
      , is_same<X3,noncopyable>
    > is_noncopyable;






    typedef typename mpl::if_<
        is_same<held_type_arg,python::detail::not_specified>, T, held_type_arg
    >::type held_type;


    typedef is_convertible<held_type*,T*> use_value_holder;



    typedef typename mpl::eval_if<
        use_value_holder
      , mpl::identity<held_type>
      , pointee<held_type>
    >::type wrapped;


    typedef mpl::or_<
        has_back_reference<T>
      , is_same<held_type_arg,T>
      , is_base_and_derived<T,wrapped>
    > use_back_reference;


    typedef typename mpl::eval_if<
        use_back_reference
      , mpl::if_<
            use_value_holder
          , value_holder_back_reference<T, wrapped>
          , pointer_holder_back_reference<held_type,T>
        >
      , mpl::if_<
            use_value_holder
          , value_holder<T>
          , pointer_holder<held_type,wrapped>
        >
    >::type holder;

    inline static void register_()
    {
        class_metadata::register_aux((T*)0);
    }

 private:
    template <class T2>
    inline static void register_aux(python::wrapper<T2>*)
    {
        typedef typename mpl::not_<is_same<T2,wrapped> >::type use_callback;
        class_metadata::register_aux2((T2*)0, use_callback());
    }

    inline static void register_aux(void*)
    {
        typedef typename is_base_and_derived<T,wrapped>::type use_callback;
        class_metadata::register_aux2((T*)0, use_callback());
    }

    template <class T2, class Callback>
    inline static void register_aux2(T2*, Callback)
    {
        objects::register_shared_ptr_from_python_and_casts((T2*)0, bases());

        class_metadata::maybe_register_callback_class((T2*)0, Callback());

        class_metadata::maybe_register_class_to_python((T2*)0, is_noncopyable());

        class_metadata::maybe_register_pointer_to_python(
            (T2*)0, (use_value_holder*)0, (use_back_reference*)0);
    }





    inline static void maybe_register_pointer_to_python(...) {}


    inline static void maybe_register_pointer_to_python(void*,void*,mpl::true_*)
    {
        objects::copy_class_object(python::type_id<T>(), python::type_id<back_reference<T const &> >());
        objects::copy_class_object(python::type_id<T>(), python::type_id<back_reference<T &> >());
    }


    template <class T2>
    inline static void maybe_register_pointer_to_python(T2*, mpl::false_*, mpl::false_*)
    {
        python::detail::force_instantiate(
            objects::class_value_wrapper<
                held_type
              , make_ptr_instance<T2, pointer_holder<held_type, T2> >
            >()
        );


        objects::copy_class_object(python::type_id<T2>(), python::type_id<held_type>());

    }



    inline static void maybe_register_class_to_python(void*, mpl::true_) {}


    template <class T2>
    inline static void maybe_register_class_to_python(T2*, mpl::false_)
    {
        python::detail::force_instantiate(class_cref_wrapper<T2, make_instance<T2, holder> >());


        objects::copy_class_object(python::type_id<T2>(), python::type_id<held_type>());

    }




    inline static void maybe_register_callback_class(void*, mpl::false_) {}

    template <class T2>
    inline static void maybe_register_callback_class(T2*, mpl::true_)
    {
        objects::register_shared_ptr_from_python_and_casts(
            (wrapped*)0, mpl::single_view<T2>());


        objects::copy_class_object(python::type_id<T2>(), python::type_id<wrapped>());
    }
};

}}}
# 24 "/usr/include/boost-1_42/boost/python/class.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/pickle_support.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/object/pickle_support.hpp"
namespace boost { namespace python {

namespace api
{
  class object;
}
using api::object;
class tuple;

 object const& make_instance_reduce_function();

struct pickle_suite;

namespace error_messages {

  template <class T>
  struct missing_pickle_suite_function_or_incorrect_signature {};

  inline void must_be_derived_from_pickle_suite(pickle_suite const&) {}
}

namespace detail { struct pickle_suite_registration; }

struct pickle_suite
{
  private:
    struct inaccessible {};
    friend struct detail::pickle_suite_registration;
  public:
    static inaccessible* getinitargs() { return 0; }
    static inaccessible* getstate() { return 0; }
    static inaccessible* setstate() { return 0; }
    static bool getstate_manages_dict() { return false; }
};

namespace detail {

  struct pickle_suite_registration
  {
    typedef pickle_suite::inaccessible inaccessible;

    template <class Class_, class Tgetinitargs>
    static
    void
    register_(
      Class_& cl,
      tuple (*getinitargs_fn)(Tgetinitargs),
      inaccessible* (* )(),
      inaccessible* (* )(),
      bool)
    {
      cl.enable_pickling_(false);
      cl.def("__getinitargs__", getinitargs_fn);
    }

    template <class Class_,
              class Rgetstate, class Tgetstate,
              class Tsetstate, class Ttuple>
    static
    void
    register_(
      Class_& cl,
      inaccessible* (* )(),
      Rgetstate (*getstate_fn)(Tgetstate),
      void (*setstate_fn)(Tsetstate, Ttuple),
      bool getstate_manages_dict)
    {
      cl.enable_pickling_(getstate_manages_dict);
      cl.def("__getstate__", getstate_fn);
      cl.def("__setstate__", setstate_fn);
    }

    template <class Class_,
              class Tgetinitargs,
              class Rgetstate, class Tgetstate,
              class Tsetstate, class Ttuple>
    static
    void
    register_(
      Class_& cl,
      tuple (*getinitargs_fn)(Tgetinitargs),
      Rgetstate (*getstate_fn)(Tgetstate),
      void (*setstate_fn)(Tsetstate, Ttuple),
      bool getstate_manages_dict)
    {
      cl.enable_pickling_(getstate_manages_dict);
      cl.def("__getinitargs__", getinitargs_fn);
      cl.def("__getstate__", getstate_fn);
      cl.def("__setstate__", setstate_fn);
    }

    template <class Class_>
    static
    void
    register_(
      Class_&,
      ...)
    {
      typedef typename
        error_messages::missing_pickle_suite_function_or_incorrect_signature<
          Class_>::error_type error_type;
    }
  };

  template <typename PickleSuiteType>
  struct pickle_suite_finalize
  : PickleSuiteType,
    pickle_suite_registration
  {};

}

}}
# 25 "/usr/include/boost-1_42/boost/python/class.hpp" 2


# 1 "/usr/include/boost-1_42/boost/python/detail/overloads_fwd.hpp" 1







namespace boost { namespace python { namespace detail {


struct overloads_base;

template <class OverloadsT, class NameSpaceT, class SigT>
inline void define_with_defaults(char const* name, OverloadsT const&, NameSpaceT&, SigT const&);

}}}
# 28 "/usr/include/boost-1_42/boost/python/class.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/operator_id.hpp" 1







namespace boost { namespace python { namespace detail {

enum operator_id
{
    op_add,
    op_sub,
    op_mul,
    op_div,
    op_mod,
    op_divmod,
    op_pow,
    op_lshift,
    op_rshift,
    op_and,
    op_xor,
    op_or,
    op_neg,
    op_pos,
    op_abs,
    op_invert,
    op_int,
    op_long,
    op_float,
    op_str,
    op_cmp,
    op_gt,
    op_ge,
    op_lt,
    op_le,
    op_eq,
    op_ne,
    op_iadd,
    op_isub,
    op_imul,
    op_idiv,
    op_imod,
    op_ilshift,
    op_irshift,
    op_iand,
    op_ixor,
    op_ior,
    op_complex,



    op_nonzero,

    op_repr
};

}}}
# 29 "/usr/include/boost-1_42/boost/python/class.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/def_helper.hpp" 1
# 17 "/usr/include/boost-1_42/boost/python/detail/def_helper.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
# 18 "/usr/include/boost-1_42/boost/python/detail/def_helper.hpp" 2
# 1 "/usr/include/boost-1_42/boost/tuple/tuple.hpp" 1
# 33 "/usr/include/boost-1_42/boost/tuple/tuple.hpp"
# 1 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp" 1
# 43 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp"
namespace boost {
namespace tuples {


struct null_type {};


namespace detail {
  inline const null_type cnull() { return null_type(); }





template <bool If, class Then, class Else> struct IF { typedef Then RET; };

template <class Then, class Else> struct IF<false, Then, Else> {
  typedef Else RET;
};

}


template <class HT, class TT> struct cons;



template <
  class T0 = null_type, class T1 = null_type, class T2 = null_type,
  class T3 = null_type, class T4 = null_type, class T5 = null_type,
  class T6 = null_type, class T7 = null_type, class T8 = null_type,
  class T9 = null_type>
class tuple;


template<class T> struct length;



namespace detail {



template<class T>
class generate_error;




template< int N >
struct get_class {
  template<class RET, class HT, class TT >
  inline static RET get(const cons<HT, TT>& t)
  {





    return get_class<N-1>::template get<RET>(t.tail);

  }
  template<class RET, class HT, class TT >
  inline static RET get(cons<HT, TT>& t)
  {



    return get_class<N-1>::template get<RET>(t.tail);

  }
};

template<>
struct get_class<0> {
  template<class RET, class HT, class TT>
  inline static RET get(const cons<HT, TT>& t)
  {
    return t.head;
  }
  template<class RET, class HT, class TT>
  inline static RET get(cons<HT, TT>& t)
  {
    return t.head;
  }
};

}
# 140 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp"
template<int N, class T>
struct element
{
private:
  typedef typename T::tail_type Next;
public:
  typedef typename element<N-1, Next>::type type;
};
template<class T>
struct element<0,T>
{
  typedef typename T::head_type type;
};

template<int N, class T>
struct element<N, const T>
{
private:
  typedef typename T::tail_type Next;
  typedef typename element<N-1, Next>::type unqualified_type;
public:



  typedef typename boost::add_const<unqualified_type>::type type;


};
template<class T>
struct element<0,const T>
{



  typedef typename boost::add_const<typename T::head_type>::type type;

};
# 233 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp"
template <class T> struct access_traits {
  typedef const T& const_type;
  typedef T& non_const_type;

  typedef const typename boost::remove_cv<T>::type& parameter_type;






};

template <class T> struct access_traits<T&> {

  typedef T& const_type;
  typedef T& non_const_type;

  typedef T& parameter_type;
};



template<int N, class HT, class TT>
inline typename access_traits<
                  typename element<N, cons<HT, TT> >::type
                >::non_const_type
get(cons<HT, TT>& c ) {



  return detail::get_class<N>::template

         get<
           typename access_traits<
             typename element<N, cons<HT, TT> >::type
           >::non_const_type,
           HT,TT
         >(c);
}




template<int N, class HT, class TT>
inline typename access_traits<
                  typename element<N, cons<HT, TT> >::type
                >::const_type
get(const cons<HT, TT>& c ) {



  return detail::get_class<N>::template

         get<
           typename access_traits<
             typename element<N, cons<HT, TT> >::type
           >::const_type,
           HT,TT
         >(c);
}


namespace detail {







template <class T> class non_storeable_type {
  non_storeable_type();
};

template <class T> struct wrap_non_storeable_type {
  typedef typename IF<
    ::boost::is_function<T>::value, non_storeable_type<T>, T
  >::RET type;
};
template <> struct wrap_non_storeable_type<void> {
  typedef non_storeable_type<void> type;
};

}

template <class HT, class TT>
struct cons {

  typedef HT head_type;
  typedef TT tail_type;

  typedef typename
    detail::wrap_non_storeable_type<head_type>::type stored_head_type;

  stored_head_type head;
  tail_type tail;

  typename access_traits<stored_head_type>::non_const_type
  get_head() { return head; }

  typename access_traits<tail_type>::non_const_type
  get_tail() { return tail; }

  typename access_traits<stored_head_type>::const_type
  get_head() const { return head; }

  typename access_traits<tail_type>::const_type
  get_tail() const { return tail; }

  cons() : head(), tail() {}







  cons(typename access_traits<stored_head_type>::parameter_type h,
       const tail_type& t)
    : head (h), tail(t) {}

  template <class T1, class T2, class T3, class T4, class T5,
            class T6, class T7, class T8, class T9, class T10>
  cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
    : head (t1),
      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
      {}

  template <class T2, class T3, class T4, class T5,
            class T6, class T7, class T8, class T9, class T10>
  cons( const null_type& , T2& t2, T3& t3, T4& t4, T5& t5,
        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
    : head (),
      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
      {}


  template <class HT2, class TT2>
  cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}

  template <class HT2, class TT2>
  cons& operator=( const cons<HT2, TT2>& u ) {
    head=u.head; tail=u.tail; return *this;
  }



  cons& operator=(const cons& u) {
    head = u.head; tail = u.tail; return *this;
  }

  template <class T1, class T2>
  cons& operator=( const std::pair<T1, T2>& u ) {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((length<cons>::value == 2) == 0 ? false : true) >)> boost_static_assert_typedef_388;
    head = u.first; tail.head = u.second; return *this;
  }


  template <int N>
  typename access_traits<
             typename element<N, cons<HT, TT> >::type
           >::non_const_type
  get() {
    return boost::tuples::get<N>(*this);
  }

  template <int N>
  typename access_traits<
             typename element<N, cons<HT, TT> >::type
           >::const_type
  get() const {
    return boost::tuples::get<N>(*this);
  }
};

template <class HT>
struct cons<HT, null_type> {

  typedef HT head_type;
  typedef null_type tail_type;
  typedef cons<HT, null_type> self_type;

  typedef typename
    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
  stored_head_type head;

  typename access_traits<stored_head_type>::non_const_type
  get_head() { return head; }

  null_type get_tail() { return null_type(); }

  typename access_traits<stored_head_type>::const_type
  get_head() const { return head; }

  const null_type get_tail() const { return null_type(); }


  cons() : head() {}

  cons(typename access_traits<stored_head_type>::parameter_type h,
       const null_type& = null_type())
    : head (h) {}

  template<class T1>
  cons(T1& t1, const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&)
  : head (t1) {}

  cons(const null_type&,
       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&)
  : head () {}

  template <class HT2>
  cons( const cons<HT2, null_type>& u ) : head(u.head) {}

  template <class HT2>
  cons& operator=(const cons<HT2, null_type>& u )
  { head = u.head; return *this; }



  cons& operator=(const cons& u) { head = u.head; return *this; }

  template <int N>
  typename access_traits<
             typename element<N, self_type>::type
            >::non_const_type
  get() {
    return boost::tuples::get<N>(*this);
  }

  template <int N>
  typename access_traits<
             typename element<N, self_type>::type
           >::const_type
  get() const {
    return boost::tuples::get<N>(*this);
  }

};



template<class T>
struct length {
  static const int value = 1 + length<typename T::tail_type>::value;
};

template<>
struct length<tuple<> > {
  static const int value = 0;
};

template<>
struct length<tuple<> const> {
  static const int value = 0;
};

template<>
struct length<null_type> {
  static const int value = 0;
};

template<>
struct length<null_type const> {
  static const int value = 0;
};

namespace detail {


template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>
struct map_tuple_to_cons
{
  typedef cons<T0,
               typename map_tuple_to_cons<T1, T2, T3, T4, T5,
                                          T6, T7, T8, T9, null_type>::type
              > type;
};


template <>
struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
{
  typedef null_type type;
};

}



template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>

class tuple :
  public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
{
public:
  typedef typename
    detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
  typedef typename inherited::head_type head_type;
  typedef typename inherited::tail_type tail_type;



  tuple() {}

  tuple(typename access_traits<T0>::parameter_type t0)
    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1)
    : inherited(t0, t1, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2)
    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3)
    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4)
    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5)
    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6)
    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6,
        typename access_traits<T7>::parameter_type t7)
    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
                detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6,
        typename access_traits<T7>::parameter_type t7,
        typename access_traits<T8>::parameter_type t8)
    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6,
        typename access_traits<T7>::parameter_type t7,
        typename access_traits<T8>::parameter_type t8,
        typename access_traits<T9>::parameter_type t9)
    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}


  template<class U1, class U2>
  tuple(const cons<U1, U2>& p) : inherited(p) {}

  template <class U1, class U2>
  tuple& operator=(const cons<U1, U2>& k) {
    inherited::operator=(k);
    return *this;
  }

  template <class U1, class U2>
  tuple& operator=(const std::pair<U1, U2>& k) {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((length<tuple>::value == 2) == 0 ? false : true) >)> boost_static_assert_typedef_645;
    this->head = k.first;
    this->tail.head = k.second;
    return *this;
  }

};


template <>
class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> :
  public null_type
{
public:
  typedef null_type inherited;
};



namespace detail {

struct swallow_assign {

  template<typename T>
  swallow_assign const& operator=(const T&) const {
    return *this;
  }
};

}


detail::swallow_assign const ignore = detail::swallow_assign();
# 696 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp"
template<class T>
struct make_tuple_traits {
  typedef T type;







};
# 720 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp"
template<class T>
struct make_tuple_traits<T&> {
  typedef typename
     detail::generate_error<T&>::
       do_not_use_with_reference_type error;
};





template<class T, int n> struct make_tuple_traits <T[n]> {
  typedef const T (&type)[n];
};

template<class T, int n>
struct make_tuple_traits<const T[n]> {
  typedef const T (&type)[n];
};

template<class T, int n> struct make_tuple_traits<volatile T[n]> {
  typedef const volatile T (&type)[n];
};

template<class T, int n>
struct make_tuple_traits<const volatile T[n]> {
  typedef const volatile T (&type)[n];
};

template<class T>
struct make_tuple_traits<reference_wrapper<T> >{
  typedef T& type;
};

template<class T>
struct make_tuple_traits<const reference_wrapper<T> >{
  typedef T& type;
};




namespace detail {



template <
  class T0 = null_type, class T1 = null_type, class T2 = null_type,
  class T3 = null_type, class T4 = null_type, class T5 = null_type,
  class T6 = null_type, class T7 = null_type, class T8 = null_type,
  class T9 = null_type
>
struct make_tuple_mapper {
  typedef
    tuple<typename make_tuple_traits<T0>::type,
          typename make_tuple_traits<T1>::type,
          typename make_tuple_traits<T2>::type,
          typename make_tuple_traits<T3>::type,
          typename make_tuple_traits<T4>::type,
          typename make_tuple_traits<T5>::type,
          typename make_tuple_traits<T6>::type,
          typename make_tuple_traits<T7>::type,
          typename make_tuple_traits<T8>::type,
          typename make_tuple_traits<T9>::type> type;
};

}


inline tuple<> make_tuple() {
  return tuple<>();
}

template<class T0>
inline typename detail::make_tuple_mapper<T0>::type
make_tuple(const T0& t0) {
  typedef typename detail::make_tuple_mapper<T0>::type t;
  return t(t0);
}

template<class T0, class T1>
inline typename detail::make_tuple_mapper<T0, T1>::type
make_tuple(const T0& t0, const T1& t1) {
  typedef typename detail::make_tuple_mapper<T0, T1>::type t;
  return t(t0, t1);
}

template<class T0, class T1, class T2>
inline typename detail::make_tuple_mapper<T0, T1, T2>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
  return t(t0, t1, t2);
}

template<class T0, class T1, class T2, class T3>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
  return t(t0, t1, t2, t3);
}

template<class T0, class T1, class T2, class T3, class T4>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
  return t(t0, t1, t2, t3, t4);
}

template<class T0, class T1, class T2, class T3, class T4, class T5>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
  return t(t0, t1, t2, t3, t4, t5);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7, class T8>
inline typename detail::make_tuple_mapper
  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
                  const T8& t8) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7, class T8, class T9>
inline typename detail::make_tuple_mapper
  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
                  const T8& t8, const T9& t9) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
}




template<class T1>
inline tuple<T1&> tie(T1& t1) {
  return tuple<T1&> (t1);
}

template<class T1, class T2>
inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
  return tuple<T1&, T2&> (t1, t2);
}

template<class T1, class T2, class T3>
inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
  return tuple<T1&, T2&, T3&> (t1, t2, t3);
}

template<class T1, class T2, class T3, class T4>
inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
  return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
}

template<class T1, class T2, class T3, class T4, class T5>
inline tuple<T1&, T2&, T3&, T4&, T5&>
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
  return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
}

template<class T1, class T2, class T3, class T4, class T5, class T6>
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
  return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
}

template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
}

template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
         class T8>
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
           (t1, t2, t3, t4, t5, t6, t7, t8);
}

template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
         class T8, class T9>
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
           T9& t9) {
  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
            (t1, t2, t3, t4, t5, t6, t7, t8, t9);
}

template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
         class T8, class T9, class T10>
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
           T9& t9, T10& t10) {
  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
           (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
}

}
}
# 34 "/usr/include/boost-1_42/boost/tuple/tuple.hpp" 2



namespace boost {

using tuples::tuple;
using tuples::make_tuple;
using tuples::tie;

using tuples::get;
# 87 "/usr/include/boost-1_42/boost/tuple/tuple.hpp"
}
# 19 "/usr/include/boost-1_42/boost/python/detail/def_helper.hpp" 2



namespace boost { namespace python {

struct default_call_policies;

namespace detail
{




  template <class Tuple, class Predicate>
  struct tuple_extract;



  template <bool matched>
  struct tuple_extract_impl
  {
      template <class Tuple, class Predicate>
      struct apply
      {
          typedef typename Tuple::head_type result_type;

          static typename Tuple::head_type extract(Tuple const& x)
          {
              return x.get_head();
          }
      };
  };



  template <>
  struct tuple_extract_impl<false>
  {
      template <class Tuple, class Predicate>
      struct apply
      {

          typedef tuple_extract<typename Tuple::tail_type, Predicate> next;
          typedef typename next::result_type result_type;

          static result_type extract(Tuple const& x)
          {
              return next::extract(x.get_tail());
          }
      };
  };



  template <class Tuple, class Predicate>
  struct tuple_extract_base_select
  {
      typedef typename Tuple::head_type head_type;
      typedef typename mpl::apply1<Predicate, typename add_reference<head_type>::type>::type match_t;
      static const bool match = match_t::value;
      typedef typename tuple_extract_impl<match>::template apply<Tuple,Predicate> type;
  };

  template <class Tuple, class Predicate>
  struct tuple_extract
      : tuple_extract_base_select<
         Tuple
         , typename mpl::lambda<Predicate>::type
      >::type
  {
  };







  template <class Tuple>
  struct doc_extract
      : tuple_extract<
        Tuple
        , mpl::not_<
           mpl::or_<
               indirect_traits::is_reference_to_class<mpl::_1>
             , indirect_traits::is_reference_to_member_function_pointer<mpl::_1 >
           >
        >
     >
  {
  };

  template <class Tuple>
  struct keyword_extract
      : tuple_extract<Tuple, is_reference_to_keywords<mpl::_1 > >
  {
  };

  template <class Tuple>
  struct policy_extract
      : tuple_extract<
          Tuple
          , mpl::and_<
             mpl::not_<is_same<not_specified const&,mpl::_1> >
              , indirect_traits::is_reference_to_class<mpl::_1 >
              , mpl::not_<is_reference_to_keywords<mpl::_1 > >
          >
        >
  {
  };

  template <class Tuple>
  struct default_implementation_extract
      : tuple_extract<
          Tuple
          , indirect_traits::is_reference_to_member_function_pointer<mpl::_1 >
          >
  {
  };
# 146 "/usr/include/boost-1_42/boost/python/detail/def_helper.hpp"
  template <class T1, class T2, class T3, class T4>
  struct def_helper
  {



      typedef boost::tuples::tuple<
          T1 const&
          , T2 const&
          , T3 const&
          , T4 const&
          , default_call_policies
          , detail::keywords<0>
          , char const*
          , void(not_specified::*)()

          > all_t;



      def_helper(T1 const& a1) : m_all(a1,m_nil,m_nil,m_nil) {}
      def_helper(T1 const& a1, T2 const& a2) : m_all(a1,a2,m_nil,m_nil) {}
      def_helper(T1 const& a1, T2 const& a2, T3 const& a3) : m_all(a1,a2,a3,m_nil) {}
      def_helper(T1 const& a1, T2 const& a2, T3 const& a3, T4 const& a4) : m_all(a1,a2,a3,a4) {}

   private:
      typedef typename default_implementation_extract<all_t>::result_type default_implementation_t;

   public:



      static const bool has_default_implementation = ( !is_same<default_implementation_t, void(not_specified::*)()>::value)

                                                                                   ;

   public:

      char const* doc() const
      {
          return doc_extract<all_t>::extract(m_all);
      }

      typename keyword_extract<all_t>::result_type keywords() const
      {
          return keyword_extract<all_t>::extract(m_all);
      }

      typename policy_extract<all_t>::result_type policies() const
      {
          return policy_extract<all_t>::extract(m_all);
      }

      default_implementation_t default_implementation() const
      {
          return default_implementation_extract<all_t>::extract(m_all);
      }

   private:
      all_t m_all;
      not_specified m_nil;
  };
}

}}
# 30 "/usr/include/boost-1_42/boost/python/class.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/detail/unwrap_type_id.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/detail/unwrap_type_id.hpp"
namespace boost { namespace python {

template <class T> class wrapper;

namespace detail {

template <class T>
inline type_info unwrap_type_id(T*, ...)
{
    return type_id<T>();
}

template <class U, class T>
inline type_info unwrap_type_id(U*, wrapper<T>*)
{
    return type_id<T>();
}

}}}
# 32 "/usr/include/boost-1_42/boost/python/class.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/unwrap_wrapper.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/detail/is_wrapper.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/detail/is_wrapper.hpp"
namespace boost { namespace python {

template <class T> class wrapper;

namespace detail
{
  typedef char (&is_not_wrapper)[2];
  is_not_wrapper is_wrapper_helper(...);
  template <class T>
  char is_wrapper_helper(wrapper<T> const volatile*);


  template <class T>
  struct is_wrapper
    : mpl::bool_<(sizeof(detail::is_wrapper_helper((T*)0)) == 1)>
  {};

}}}
# 9 "/usr/include/boost-1_42/boost/python/detail/unwrap_wrapper.hpp" 2



namespace boost { namespace python { namespace detail {

template <class T>
struct unwrap_wrapper_helper
{
    typedef typename T::_wrapper_wrapped_type_ type;
};

template <class T>
struct unwrap_wrapper_
  : mpl::eval_if<is_wrapper<T>,unwrap_wrapper_helper<T>,mpl::identity<T> >
{};

template <class T>
typename unwrap_wrapper_<T>::type*
unwrap_wrapper(T*)
{
    return 0;
}

}}}
# 33 "/usr/include/boost-1_42/boost/python/class.hpp" 2
# 60 "/usr/include/boost-1_42/boost/python/class.hpp"
namespace boost { namespace python {

template <class DerivedVisitor> class def_visitor;

enum no_init_t { no_init };

namespace detail
{



  struct write_type_id
  {
      write_type_id(type_info**p) : p(p) {}


      template <class T>
      void operator()(T*) const
      {
          *(*p)++ = type_id<T>();
      }

      type_info** p;
  };

  template <class T>
  struct is_data_member_pointer
      : mpl::and_<
            is_member_pointer<T>
          , mpl::not_<is_member_function_pointer<T> >
        >
  {};
# 107 "/usr/include/boost-1_42/boost/python/class.hpp"
  namespace error
  {
# 118 "/usr/include/boost-1_42/boost/python/class.hpp"
    template <class C> struct assertion_failed { };
    template <class C> struct assertion_ok { typedef C failed; };

    template <class C>
    struct assertion
        : mpl::if_<C, assertion_ok<C>, assertion_failed<C> >::type
    {};






    template <class Default>
    void not_a_derived_class_member(Default) {}

    template <class T, class Fn>
    struct virtual_function_default
    {
        template <class Default>
        static void
        must_be_derived_class_member(Default const&)
        {
            typedef typename assertion<mpl::not_<is_same<Default,Fn> > >::failed test0;

            typedef typename assertion<is_polymorphic<T> >::failed test1;

            typedef typename assertion<is_member_function_pointer<Fn> >::failed test2;
            not_a_derived_class_member<Default>(Fn());
        }
    };
  }
}



template <
    class W
    , class X1
    , class X2
    , class X3
    >
class class_ : public objects::class_base
{
 public:
    typedef objects::class_base base;
    typedef class_<W,X1,X2,X3> self;
    typedef typename objects::class_metadata<W,X1,X2,X3> metadata;
    typedef W wrapped_type;

 private:



    struct id_vector
    {
        typedef typename metadata::bases bases;

        id_vector()
        {

            ids[0] = detail::unwrap_type_id((W*)0, (W*)0);


            type_info* p = ids + 1;
            mpl::for_each(detail::write_type_id(&p), (bases*)0, (add_pointer<mpl::_>*)0);
        }

        static const std::size_t size = mpl::size<bases>::value + 1
                                                            ;
        type_info ids[size];
    };
    friend struct id_vector;

 public:


    class_(char const* name, char const* doc = 0);


    class_(char const* name, no_init_t);


    class_(char const* name, char const* doc, no_init_t);


    template <class DerivedT>
    inline class_(char const* name, init_base<DerivedT> const& i)
        : base(name, id_vector::size, id_vector().ids)
    {
        this->initialize(i);
    }


    template <class DerivedT>
    inline class_(char const* name, char const* doc, init_base<DerivedT> const& i)
        : base(name, id_vector::size, id_vector().ids, doc)
    {
        this->initialize(i);
    }

 public:


    template <class Derived>
    self& def(def_visitor<Derived> const& visitor)
    {
        visitor.visit(*this);
        return *this;
    }




    template <class F>
    self& def(char const* name, F f)
    {
        this->def_impl(
            detail::unwrap_wrapper((W*)0)
          , name, f, detail::def_helper<char const*>(0), &f);
        return *this;
    }

    template <class A1, class A2>
    self& def(char const* name, A1 a1, A2 const& a2)
    {
        this->def_maybe_overloads(name, a1, a2, &a2);
        return *this;
    }

    template <class Fn, class A1, class A2>
    self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2)
    {




        this->def_impl(
            detail::unwrap_wrapper((W*)0)
          , name, fn
          , detail::def_helper<A1,A2>(a1,a2)
          , &fn);

        return *this;
    }

    template <class Fn, class A1, class A2, class A3>
    self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2, A3 const& a3)
    {
        this->def_impl(
            detail::unwrap_wrapper((W*)0)
          , name, fn
          , detail::def_helper<A1,A2,A3>(a1,a2,a3)
          , &fn);

        return *this;
    }




    template <class D>
    self& def_readonly(char const* name, D const& d, char const* doc=0)
    {
        return this->def_readonly_impl(name, d, doc );
    }

    template <class D>
    self& def_readwrite(char const* name, D const& d, char const* doc=0)
    {
        return this->def_readwrite_impl(name, d, doc );
    }

    template <class D>
    self& def_readonly(char const* name, D& d, char const* doc=0)
    {
        return this->def_readonly_impl(name, d, doc );
    }

    template <class D>
    self& def_readwrite(char const* name, D& d, char const* doc=0)
    {
        return this->def_readwrite_impl(name, d, doc );
    }



    template <class Get>
    self& add_property(char const* name, Get fget, char const* docstr = 0)
    {
        base::add_property(name, this->make_getter(fget), docstr);
        return *this;
    }

    template <class Get, class Set>
    self& add_property(char const* name, Get fget, Set fset, char const* docstr = 0)
    {
        base::add_property(
            name, this->make_getter(fget), this->make_setter(fset), docstr);
        return *this;
    }
# 361 "/usr/include/boost-1_42/boost/python/class.hpp"
    template <class Get>
    self& add_static_property(char const* name, Get fget)
    {
        base::add_static_property(name, object(fget));
        return *this;
    }

    template <class Get, class Set>
    self& add_static_property(char const* name, Get fget, Set fset)
    {
        base::add_static_property(name, object(fget), object(fset));
        return *this;
    }

    template <class U>
    self& setattr(char const* name, U const& x)
    {
        this->base::setattr(name, object(x));
        return *this;
    }


    template <typename PickleSuiteType>
    self& def_pickle(PickleSuiteType const& x)
    {
      error_messages::must_be_derived_from_pickle_suite(x);
      detail::pickle_suite_finalize<PickleSuiteType>::register_(
        *this,
        &PickleSuiteType::getinitargs,
        &PickleSuiteType::getstate,
        &PickleSuiteType::setstate,
        PickleSuiteType::getstate_manages_dict());
      return *this;
    }

    self& enable_pickling()
    {
        this->base::enable_pickling_(false);
        return *this;
    }

    self& staticmethod(char const* name)
    {
        this->make_method_static(name);
        return *this;
    }
 private:
# 416 "/usr/include/boost-1_42/boost/python/class.hpp"
    template <class F>
    object make_getter(F f)
    {
        typedef typename api::is_object_operators<F>::type is_obj_or_proxy;

        return this->make_fn_impl(
            detail::unwrap_wrapper((W*)0)
          , f, is_obj_or_proxy(), (char*)0, detail::is_data_member_pointer<F>()
        );
    }

    template <class F>
    object make_setter(F f)
    {
        typedef typename api::is_object_operators<F>::type is_obj_or_proxy;

        return this->make_fn_impl(
            detail::unwrap_wrapper((W*)0)
          , f, is_obj_or_proxy(), (int*)0, detail::is_data_member_pointer<F>()
        );
    }

    template <class T, class F>
    object make_fn_impl(T*, F const& f, mpl::false_, void*, mpl::false_)
    {
        return python::make_function(f, default_call_policies(), detail::get_signature(f, (T*)0));
    }

    template <class T, class D, class B>
    object make_fn_impl(T*, D B::*pm_, mpl::false_, char*, mpl::true_)
    {
        D T::*pm = pm_;
        return python::make_getter(pm);
    }

    template <class T, class D, class B>
    object make_fn_impl(T*, D B::*pm_, mpl::false_, int*, mpl::true_)
    {
        D T::*pm = pm_;
        return python::make_setter(pm);
    }

    template <class T, class F>
    object make_fn_impl(T*, F const& x, mpl::true_, void*, mpl::false_)
    {
        return x;
    }


    template <class D, class B>
    self& def_readonly_impl(
        char const* name, D B::*pm_, char const* doc )
    {
        return this->add_property(name, pm_, doc);
    }

    template <class D, class B>
    self& def_readwrite_impl(
        char const* name, D B::*pm_, char const* doc )
    {
        return this->add_property(name, pm_, pm_, doc);
    }

    template <class D>
    self& def_readonly_impl(
        char const* name, D& d, char const* )
    {
        return this->add_static_property(name, python::make_getter(d));
    }

    template <class D>
    self& def_readwrite_impl(
        char const* name, D& d, char const* )
    {
        return this->add_static_property(name, python::make_getter(d), python::make_setter(d));
    }

    template <class DefVisitor>
    inline void initialize(DefVisitor const& i)
    {
        metadata::register_();

        typedef typename metadata::holder holder;
        this->set_instance_size( objects::additional_instance_size<holder>::value );

        this->def(i);
    }

    inline void initialize(no_init_t)
    {
        metadata::register_();
        this->def_no_init();
    }






    template <class T, class Helper, class LeafVisitor, class Visitor>
    inline void def_impl(
        T*
      , char const* name
      , LeafVisitor
      , Helper const& helper
      , def_visitor<Visitor> const* v
    )
    {
        v->visit(*this, name, helper);
    }

    template <class T, class Fn, class Helper>
    inline void def_impl(
        T*
      , char const* name
      , Fn fn
      , Helper const& helper
      , ...
    )
    {
        objects::add_to_namespace(
            *this
          , name
          , make_function(
                fn
              , helper.policies()
              , helper.keywords()
              , detail::get_signature(fn, (T*)0)
            )
          , helper.doc()
        );

        this->def_default(name, fn, helper, mpl::bool_<Helper::has_default_implementation>());
    }
# 558 "/usr/include/boost-1_42/boost/python/class.hpp"
    template <class Fn, class Helper>
    inline void def_default(
        char const* name
        , Fn
        , Helper const& helper
        , mpl::bool_<true>)
    {
        detail::error::virtual_function_default<W,Fn>::must_be_derived_class_member(
            helper.default_implementation());

        objects::add_to_namespace(
            *this, name,
            make_function(
                helper.default_implementation(), helper.policies(), helper.keywords())
            );
    }

    template <class Fn, class Helper>
    inline void def_default(char const*, Fn, Helper const&, mpl::bool_<false>)
    { }
# 587 "/usr/include/boost-1_42/boost/python/class.hpp"
    template <class OverloadsT, class SigT>
    void def_maybe_overloads(
        char const* name
        , SigT sig
        , OverloadsT const& overloads
        , detail::overloads_base const*)

    {


        detail::define_with_defaults(
            name, overloads, *this, detail::get_signature(sig));
    }

    template <class Fn, class A1>
    void def_maybe_overloads(
        char const* name
        , Fn fn
        , A1 const& a1
        , ...)
    {
        this->def_impl(
            detail::unwrap_wrapper((W*)0)
          , name
          , fn
          , detail::def_helper<A1>(a1)
          , &fn
        );

    }

};






template <class W, class X1, class X2, class X3>
inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc)
    : base(name, id_vector::size, id_vector().ids, doc)
{
    this->initialize(init<>());

}

template <class W, class X1, class X2, class X3>
inline class_<W,X1,X2,X3>::class_(char const* name, no_init_t)
    : base(name, id_vector::size, id_vector().ids)
{
    this->initialize(no_init);
}

template <class W, class X1, class X2, class X3>
inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t)
    : base(name, id_vector::size, id_vector().ids, doc)
{
    this->initialize(no_init);
}

}}
# 19 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/copy_const_reference.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/copy_const_reference.hpp"
namespace boost { namespace python {

namespace detail
{
  template <class R>
  struct copy_const_reference_expects_a_const_reference_return_type

  {}

  ;
}

template <class T> struct to_python_value;

struct copy_const_reference
{
    template <class T>
    struct apply
    {
        typedef typename mpl::if_c<
            indirect_traits::is_reference_to_const<T>::value
          , to_python_value<T>
          , detail::copy_const_reference_expects_a_const_reference_return_type<T>
        >::type type;
    };
};


}}
# 20 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/copy_non_const_reference.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/copy_non_const_reference.hpp"
namespace boost { namespace python {

namespace detail
{
  template <class R>
  struct copy_non_const_reference_expects_a_non_const_reference_return_type

  {}

  ;
}

template <class T> struct to_python_value;

struct copy_non_const_reference
{
    template <class T>
    struct apply
    {
        typedef typename mpl::if_c<
            indirect_traits::is_reference_to_non_const<T>::value
            , to_python_value<T>
            , detail::copy_non_const_reference_expects_a_non_const_reference_return_type<T>
        >::type type;
    };
};


}}
# 21 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/def.hpp"
# 1 "/usr/include/boost-1_42/boost/python/scope.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/scope.hpp"
namespace boost { namespace python {

namespace detail
{


  extern PyObject* current_scope;
}

class scope
  : public object
{
 public:
    inline scope(scope const&);
    inline scope(object const&);
    inline scope();
    inline ~scope();

 private:
    PyObject* m_previous_scope;

 private:
    void operator=(scope const&);
};

inline scope::scope(object const& new_scope)
    : object(new_scope)
    , m_previous_scope(detail::current_scope)
{
    detail::current_scope = python::incref(new_scope.ptr());
}

inline scope::scope()
    : object(detail::borrowed_reference(
                 detail::current_scope ? detail::current_scope : (&_Py_NoneStruct)
                 ))
    , m_previous_scope(python::xincref(detail::current_scope))
{
}

inline scope::~scope()
{
    python::xdecref(detail::current_scope);
    detail::current_scope = m_previous_scope;
}

namespace converter
{
  template <>
  struct object_manager_traits<scope>
      : object_manager_traits<object>
  {
  };
}


inline scope::scope(scope const& new_scope)
    : object(new_scope)
    , m_previous_scope(detail::current_scope)
{
    detail::current_scope = python::incref(new_scope.ptr());
}

}}
# 15 "/usr/include/boost-1_42/boost/python/def.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/def.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/detail/scope.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/detail/scope.hpp"
namespace boost { namespace python { namespace detail {

void scope_setattr_doc(char const* name, object const& obj, char const* doc);

}}}
# 17 "/usr/include/boost-1_42/boost/python/def.hpp" 2

namespace boost { namespace python {

namespace detail
{
  namespace error
  {

    template <bool> struct multiple_functions_passed_to_def;
    template <> struct multiple_functions_passed_to_def<false> { typedef char type; };
  }





  template <class F, class Helper>
  void def_from_helper(
      char const* name, F const& fn, Helper const& helper)
  {

      typedef typename error::multiple_functions_passed_to_def<
          Helper::has_default_implementation
          >::type assertion;

      detail::scope_setattr_doc(
          name, boost::python::make_function(
              fn
              , helper.policies()
              , helper.keywords())
          , helper.doc()
          );
  }







  template <class Fn, class A1>
  void
  def_maybe_overloads(
      char const* name
      , Fn fn
      , A1 const& a1
      , ...)
  {
      detail::def_from_helper(name, fn, def_helper<A1>(a1));
  }

  template <class StubsT, class SigT>
  void def_maybe_overloads(
      char const* name
      , SigT sig
      , StubsT const& stubs
      , detail::overloads_base const*)
  {
      scope current;

      detail::define_with_defaults(
          name, stubs, current, detail::get_signature(sig));
  }

  template <class T>
  object make_function1(T fn, ...) { return make_function(fn); }

  inline
  object make_function1(object const& x, object const*) { return x; }
}

template <class Fn>
void def(char const* name, Fn fn)
{
    detail::scope_setattr_doc(name, detail::make_function1(fn, &fn), 0);
}

template <class Arg1T, class Arg2T>
void def(char const* name, Arg1T arg1, Arg2T const& arg2)
{
    detail::def_maybe_overloads(name, arg1, arg2, &arg2);
}

template <class F, class A1, class A2>
void def(char const* name, F f, A1 const& a1, A2 const& a2)
{
    detail::def_from_helper(name, f, detail::def_helper<A1,A2>(a1,a2));
}

template <class F, class A1, class A2, class A3>
void def(char const* name, F f, A1 const& a1, A2 const& a2, A3 const& a3)
{
    detail::def_from_helper(name, f, detail::def_helper<A1,A2,A3>(a1,a2,a3));
}

}}
# 23 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/dict.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/dict.hpp"
# 1 "/usr/include/boost-1_42/boost/python/list.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/list.hpp"
# 1 "/usr/include/boost-1_42/boost/python/converter/pytype_object_mgr_traits.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/converter/pytype_object_mgr_traits.hpp"
namespace boost { namespace python { namespace converter {



template <class T> struct object_manager_traits;




template <PyTypeObject* pytype, class T>
struct pytype_object_manager_traits
    : pyobject_type<T, pytype>
{
    static const bool is_specialized = true;
    static inline python::detail::new_reference adopt(PyObject*);
};




template <PyTypeObject* pytype, class T>
inline python::detail::new_reference pytype_object_manager_traits<pytype,T>::adopt(PyObject* x)
{
    return python::detail::new_reference(python::pytype_check(pytype, x));
}

}}}
# 12 "/usr/include/boost-1_42/boost/python/list.hpp" 2


namespace boost { namespace python {

namespace detail
{
  struct list_base : object
  {
      void append(object_cref);

      ssize_t count(object_cref value) const;

      void extend(object_cref sequence);

      long index(object_cref value) const;

      void insert(ssize_t index, object_cref);
      void insert(object const& index, object_cref);

      object pop();
      object pop(ssize_t index);
      object pop(object const& index);

      void remove(object_cref value);

      void reverse();

      void sort();




      void sort(object_cref cmpfunc);


   protected:
      list_base();
      explicit list_base(object_cref sequence);

      inline explicit list_base(python::detail::borrowed_reference p) : object(p) {} inline explicit list_base(python::detail::new_reference p) : object(p) {} inline explicit list_base(python::detail::new_non_null_reference p) : object(p) {}
   private:
      static detail::new_non_null_reference call(object const&);
  };
}

class list : public detail::list_base
{
    typedef detail::list_base base;
 public:
    list() {}

    template <class T>
    explicit list(T const& sequence)
        : base(object(sequence))
    {
    }

    template <class T>
    void append(T const& x)
    {
        base::append(object(x));
    }

    template <class T>
    long count(T const& value) const
    {
        return base::count(object(value));
    }

    template <class T>
    void extend(T const& x)
    {
        base::extend(object(x));
    }

    template <class T>
    long index(T const& x) const
    {
        return base::index(object(x));
    }

    template <class T>
    void insert(ssize_t index, T const& x)
    {
        base::insert(index, object(x));
    }

    template <class T>
    void insert(object const& index, T const& x)
    {
        base::insert(index, object(x));
    }

    object pop() { return base::pop(); }
    object pop(ssize_t index) { return base::pop(index); }

    template <class T>
    object pop(T const& index)
    {
        return base::pop(object(index));
    }

    template <class T>
    void remove(T const& value)
    {
        base::remove(object(value));
    }


    void sort() { base::sort(); }

    template <class T>
    void sort(T const& value)
    {
        base::sort(object(value));
    }


 public:
    inline explicit list(python::detail::borrowed_reference p) : base(p) {} inline explicit list(python::detail::new_reference p) : base(p) {} inline explicit list(python::detail::new_non_null_reference p) : base(p) {}
};




namespace converter
{
  template <>
  struct object_manager_traits<list>
      : pytype_object_manager_traits<&PyList_Type,list>
  {
  };
}

}}
# 12 "/usr/include/boost-1_42/boost/python/dict.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/tuple.hpp" 1
# 15 "/usr/include/boost-1_42/boost/python/tuple.hpp"
namespace boost { namespace python {

namespace detail
{
  struct tuple_base : object
  {
   protected:
      tuple_base();
      tuple_base(object_cref sequence);

      inline explicit tuple_base(python::detail::borrowed_reference p) : object(p) {} inline explicit tuple_base(python::detail::new_reference p) : object(p) {} inline explicit tuple_base(python::detail::new_non_null_reference p) : object(p) {}

   private:
      static detail::new_reference call(object const&);
  };
}

class tuple : public detail::tuple_base
{
    typedef detail::tuple_base base;
 public:
    tuple() {}

    template <class T>
    explicit tuple(T const& sequence)
        : base(object(sequence))
    {
    }

 public:
    inline explicit tuple(python::detail::borrowed_reference p) : base(p) {} inline explicit tuple(python::detail::new_reference p) : base(p) {} inline explicit tuple(python::detail::new_non_null_reference p) : base(p) {}
};





namespace converter
{
  template <>
  struct object_manager_traits<tuple>
      : pytype_object_manager_traits<&PyTuple_Type,tuple>
  {
  };
}


inline tuple make_tuple() { return tuple(); }


# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 52 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0>
    tuple
    make_tuple( A0 const& a0)
    {
        tuple result((detail::new_reference)::PyTuple_New(1));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr()));
        return result;
    }
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1)
    {
        tuple result((detail::new_reference)::PyTuple_New(2));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr()));
        return result;
    }
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2)
    {
        tuple result((detail::new_reference)::PyTuple_New(3));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr()));
        return result;
    }
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3)
    {
        tuple result((detail::new_reference)::PyTuple_New(4));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr()));
        return result;
    }
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4)
    {
        tuple result((detail::new_reference)::PyTuple_New(5));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr()));
        return result;
    }
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5)
    {
        tuple result((detail::new_reference)::PyTuple_New(6));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr()));
        return result;
    }
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6)
    {
        tuple result((detail::new_reference)::PyTuple_New(7));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr()));
        return result;
    }
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7)
    {
        tuple result((detail::new_reference)::PyTuple_New(8));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr()));
        return result;
    }
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8)
    {
        tuple result((detail::new_reference)::PyTuple_New(9));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr()));
        return result;
    }
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9)
    {
        tuple result((detail::new_reference)::PyTuple_New(10));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr()));
        return result;
    }
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10)
    {
        tuple result((detail::new_reference)::PyTuple_New(11));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[10] = python::incref(python::object(a10).ptr()));
        return result;
    }
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11)
    {
        tuple result((detail::new_reference)::PyTuple_New(12));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[10] = python::incref(python::object(a10).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[11] = python::incref(python::object(a11).ptr()));
        return result;
    }
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12)
    {
        tuple result((detail::new_reference)::PyTuple_New(13));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[10] = python::incref(python::object(a10).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[11] = python::incref(python::object(a11).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[12] = python::incref(python::object(a12).ptr()));
        return result;
    }
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13)
    {
        tuple result((detail::new_reference)::PyTuple_New(14));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[10] = python::incref(python::object(a10).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[11] = python::incref(python::object(a11).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[12] = python::incref(python::object(a12).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[13] = python::incref(python::object(a13).ptr()));
        return result;
    }
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
    tuple
    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14)
    {
        tuple result((detail::new_reference)::PyTuple_New(15));
        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[10] = python::incref(python::object(a10).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[11] = python::incref(python::object(a11).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[12] = python::incref(python::object(a12).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[13] = python::incref(python::object(a13).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[14] = python::incref(python::object(a14).ptr()));
        return result;
    }
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 66 "/usr/include/boost-1_42/boost/python/tuple.hpp" 2

}}
# 13 "/usr/include/boost-1_42/boost/python/dict.hpp" 2


namespace boost { namespace python {

class dict;

namespace detail
{
  struct dict_base : object
  {

      void clear();


      dict copy();


      object get(object_cref k) const;

      object get(object_cref k, object_cref d) const;


      bool has_key(object_cref k) const;


      list items() const;


      object iteritems() const;


      object iterkeys() const;


      object itervalues() const;


      list keys() const;



      tuple popitem();


      object setdefault(object_cref k);

      object setdefault(object_cref k, object_cref d);


      void update(object_cref E);


      list values() const;

   protected:




      dict_base();
      explicit dict_base(object_cref data);

      inline explicit dict_base(python::detail::borrowed_reference p) : object(p) {} inline explicit dict_base(python::detail::new_reference p) : object(p) {} inline explicit dict_base(python::detail::new_non_null_reference p) : object(p) {}
   private:
      static detail::new_reference call(object const&);
  };
}

class dict : public detail::dict_base
{
    typedef detail::dict_base base;
 public:




    dict() {}

    template <class T>
    explicit dict(T const& data)
        : base(object(data))
    {
    }

    template<class T>
    object get(T const& k) const
    {
        return base::get(object(k));
    }

    template<class T1, class T2>
    object get(T1 const& k, T2 const& d) const
    {
        return base::get(object(k),object(d));
    }

    template<class T>
    bool has_key(T const& k) const
    {
        return base::has_key(object(k));
    }

    template<class T>
    object setdefault(T const& k)
    {
        return base::setdefault(object(k));
    }

    template<class T1, class T2>
    object setdefault(T1 const& k, T2 const& d)
    {
        return base::setdefault(object(k),object(d));
    }

    template<class T>
    void update(T const& E)
    {
        base::update(object(E));
    }

 public:
    inline explicit dict(python::detail::borrowed_reference p) : base(p) {} inline explicit dict(python::detail::new_reference p) : base(p) {} inline explicit dict(python::detail::new_non_null_reference p) : base(p) {}
};




namespace converter
{
  template <>
  struct object_manager_traits<dict>
      : pytype_object_manager_traits<&PyDict_Type,dict>
  {
  };
}

}}
# 25 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/docstring_options.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/object/function.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/object/function.hpp"
# 1 "/usr/include/boost-1_42/boost/function/function2.hpp" 1
# 11 "/usr/include/boost-1_42/boost/function/function2.hpp"
# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
# 12 "/usr/include/boost-1_42/boost/function/function2.hpp" 2
# 12 "/usr/include/boost-1_42/boost/python/object/function.hpp" 2



namespace boost { namespace python { namespace objects {


struct function : PyObject
{
    function(
        py_function const&
        , python::detail::keyword const* names_and_defaults
        , unsigned num_keywords);

    ~function();

    PyObject* call(PyObject*, PyObject*) const;




    static void add_to_namespace(
        object const& name_space, char const* name, object const& attribute);

    static void add_to_namespace(
        object const& name_space, char const* name, object const& attribute, char const* doc);

    object const& doc() const;
    void doc(object const& x);

    object const& name() const;

 private:
    object signature(bool show_return_type=false) const;
    object signatures(bool show_return_type=false) const;
    void argument_error(PyObject* args, PyObject* keywords) const;
    void add_overload(handle<function> const&);

 private:
    py_function m_fn;
    handle<function> m_overloads;
    object m_name;
    object m_namespace;
    object m_doc;
    object m_arg_names;
    unsigned m_nkeyword_values;
    friend class function_doc_signature_generator;
};




inline object const& function::doc() const
{
    return this->m_doc;
}

inline void function::doc(object const& x)
{
    this->m_doc = x;
}

inline object const& function::name() const
{
    return this->m_name;
}

}}}
# 9 "/usr/include/boost-1_42/boost/python/docstring_options.hpp" 2

namespace boost { namespace python {



class docstring_options : boost::noncopyable
{
  public:
      docstring_options(bool show_all=true)
      {
          previous_show_user_defined_ = show_user_defined_;
          previous_show_py_signatures_ = show_py_signatures_;
          previous_show_cpp_signatures_ = show_cpp_signatures_;
          show_user_defined_ = show_all;
          show_cpp_signatures_ = show_all;
          show_py_signatures_ = show_all;
      }

      docstring_options(bool show_user_defined, bool show_signatures)
      {
          previous_show_user_defined_ = show_user_defined_;
          previous_show_cpp_signatures_ = show_cpp_signatures_;
          previous_show_py_signatures_ = show_py_signatures_;
          show_user_defined_ = show_user_defined;
          show_cpp_signatures_ = show_signatures;
          show_py_signatures_ = show_signatures;
      }

      docstring_options(bool show_user_defined, bool show_py_signatures, bool show_cpp_signatures)
      {
          previous_show_user_defined_ = show_user_defined_;
          previous_show_cpp_signatures_ = show_cpp_signatures_;
          previous_show_py_signatures_ = show_py_signatures_;
          show_user_defined_ = show_user_defined;
          show_cpp_signatures_ = show_cpp_signatures;
          show_py_signatures_ = show_py_signatures;
      }

      ~docstring_options()
      {
          show_user_defined_ = previous_show_user_defined_;
          show_cpp_signatures_ = previous_show_cpp_signatures_;
          show_py_signatures_ = previous_show_py_signatures_;
      }

      void
      disable_user_defined() { show_user_defined_ = false; }

      void
      enable_user_defined() { show_user_defined_ = true; }

      void
      disable_py_signatures()
      {
        show_py_signatures_ = false;
      }

      void
      enable_py_signatures()
      {
        show_py_signatures_ = true;
      }

      void
      disable_cpp_signatures()
      {
        show_cpp_signatures_ = false;
      }

      void
      enable_cpp_signatures()
      {
        show_cpp_signatures_ = true;
      }

      void
      disable_signatures()
      {
        show_cpp_signatures_ = false;
        show_py_signatures_ = false;
      }

      void
      enable_signatures()
      {
        show_cpp_signatures_ = true;
        show_py_signatures_ = true;
      }

      void
      disable_all()
      {
        show_user_defined_ = false;
        show_cpp_signatures_ = false;
        show_py_signatures_ = false;
      }

      void
      enable_all()
      {
        show_user_defined_ = true;
        show_cpp_signatures_ = true;
        show_py_signatures_ = true;
      }

      friend struct objects::function;

  private:
      static volatile bool show_user_defined_;
      static volatile bool show_cpp_signatures_;
      static volatile bool show_py_signatures_;
      bool previous_show_user_defined_;
      bool previous_show_cpp_signatures_;
      bool previous_show_py_signatures_;
};

}}
# 26 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/enum.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/enum.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/enum_base.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/object/enum_base.hpp"
namespace boost { namespace python { namespace objects {

struct enum_base : python::api::object
{
 protected:
    enum_base(
        char const* name
        , converter::to_python_function_t
        , converter::convertible_function
        , converter::constructor_function
        , type_info
        , const char *doc = 0
        );

    void add_value(char const* name, long value);
    void export_values();

    static PyObject* to_python(PyTypeObject* type, long x);
};

}}}
# 11 "/usr/include/boost-1_42/boost/python/enum.hpp" 2



namespace boost { namespace python {

template <class T>
struct enum_ : public objects::enum_base
{
    typedef objects::enum_base base;


    enum_(char const* name, char const* doc = 0);


    inline enum_<T>& value(char const* name, T);



    inline enum_<T>& export_values();
 private:
    static PyObject* to_python(void const* x);
    static void* convertible_from_python(PyObject* obj);
    static void construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data);
};

template <class T>
inline enum_<T>::enum_(char const* name, char const* doc )
    : base(
        name
        , &enum_<T>::to_python
        , &enum_<T>::convertible_from_python
        , &enum_<T>::construct
        , type_id<T>()
        , doc
        )
{
}



template <class T>
PyObject* enum_<T>::to_python(void const* x)
{
    return base::to_python(
        converter::registered<T>::converters.m_class_object
        , static_cast<long>(*(T const*)x));
}
# 66 "/usr/include/boost-1_42/boost/python/enum.hpp"
template <class T>
void* enum_<T>::convertible_from_python(PyObject* obj)
{
    return PyObject_IsInstance(
        obj
        , upcast<PyObject>(
            converter::registered<T>::converters.m_class_object))

        ? obj : 0;
}



template <class T>
void enum_<T>::construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data)
{



    T x = static_cast<T>((((PyIntObject *)(obj))->ob_ival));

    void* const storage = ((converter::rvalue_from_python_storage<T>*)data)->storage.bytes;
    new (storage) T(x);
    data->convertible = storage;
}

template <class T>
inline enum_<T>& enum_<T>::value(char const* name, T x)
{
    this->add_value(name, static_cast<long>(x));
    return *this;
}

template <class T>
inline enum_<T>& enum_<T>::export_values()
{
    this->base::export_values();
    return *this;
}

}}
# 27 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/exception_translator.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/exception_translator.hpp"
# 1 "/usr/include/boost-1_42/boost/bind.hpp" 1
# 22 "/usr/include/boost-1_42/boost/bind.hpp"
# 1 "/usr/include/boost-1_42/boost/bind/bind.hpp" 1
# 28 "/usr/include/boost-1_42/boost/bind/bind.hpp"
# 1 "/usr/include/boost-1_42/boost/is_placeholder.hpp" 1
# 21 "/usr/include/boost-1_42/boost/is_placeholder.hpp"
namespace boost
{

template< class T > struct is_placeholder
{
    enum _vt { value = 0 };
};

}
# 29 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
# 1 "/usr/include/boost-1_42/boost/bind/arg.hpp" 1
# 25 "/usr/include/boost-1_42/boost/bind/arg.hpp"
namespace boost
{

template< int I > struct arg
{
    arg()
    {
    }

    template< class T > arg( T const & )
    {

        typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
    }
};

template< int I > bool operator==( arg<I> const &, arg<I> const & )
{
    return true;
}



template< int I > struct is_placeholder< arg<I> >
{
    enum _vt { value = I };
};

template< int I > struct is_placeholder< arg<I> (*) () >
{
    enum _vt { value = I };
};



}
# 30 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2

# 1 "/usr/include/boost-1_42/boost/visit_each.hpp" 1
# 15 "/usr/include/boost-1_42/boost/visit_each.hpp"
namespace boost {
  template<typename Visitor, typename T>
  inline void visit_each(Visitor& visitor, const T& t, long)
  {
    visitor(t);
  }

  template<typename Visitor, typename T>
  inline void visit_each(Visitor& visitor, const T& t)
  {
    visit_each(visitor, t, 0);
  }
}
# 32 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
# 41 "/usr/include/boost-1_42/boost/bind/bind.hpp"
# 1 "/usr/include/boost-1_42/boost/bind/storage.hpp" 1
# 32 "/usr/include/boost-1_42/boost/bind/storage.hpp"
namespace boost
{

namespace _bi
{



template<class A1> struct storage1
{
    explicit storage1( A1 a1 ): a1_( a1 ) {}

    template<class V> void accept(V & v) const
    {
        visit_each(v, a1_, 0);
    }

    A1 a1_;
};



template<int I> struct storage1< boost::arg<I> >
{
    explicit storage1( boost::arg<I> ) {}

    template<class V> void accept(V &) const { }

    static boost::arg<I> a1_() { return boost::arg<I>(); }
};

template<int I> struct storage1< boost::arg<I> (*) () >
{
    explicit storage1( boost::arg<I> (*) () ) {}

    template<class V> void accept(V &) const { }

    static boost::arg<I> a1_() { return boost::arg<I>(); }
};





template<class A1, class A2> struct storage2: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a2_, 0);
    }

    A2 a2_;
};



template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a2_() { return boost::arg<I>(); }
};

template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a2_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a3_, 0);
    }

    A3 a3_;
};



template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> >: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a3_() { return boost::arg<I>(); }
};

template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> (*) () >: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a3_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a4_, 0);
    }

    A4 a4_;
};



template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> >: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a4_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> (*) () >: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a4_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a5_, 0);
    }

    A5 a5_;
};



template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> >: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a5_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a5_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a6_, 0);
    }

    A6 a6_;
};



template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a6_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a6_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a7_, 0);
    }

    A7 a7_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a7_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a7_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a8_, 0);
    }

    A8 a8_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a8_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a8_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a9_, 0);
    }

    A9 a9_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a9_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a9_() { return boost::arg<I>(); }
};



}

}
# 42 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2






namespace boost
{

template<class T> class weak_ptr;

namespace _bi
{



template<class R, class F> struct result_traits
{
    typedef R type;
};



struct unspecified {};

template<class F> struct result_traits<unspecified, F>
{
    typedef typename F::result_type type;
};

template<class F> struct result_traits< unspecified, reference_wrapper<F> >
{
    typedef typename F::result_type type;
};





template<class T> bool ref_compare( T const & a, T const & b, long )
{
    return a == b;
}

template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
{
    return true;
}

template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
{
    return true;
}

template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
{
    return a.get_pointer() == b.get_pointer();
}



template<class R, class F, class L> class bind_t;

template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
{
    return a.compare( b );
}



template<class T> class value
{
public:

    value(T const & t): t_(t) {}

    T & get() { return t_; }
    T const & get() const { return t_; }

    bool operator==(value const & rhs) const
    {
        return t_ == rhs.t_;
    }

private:

    T t_;
};



template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
{
    return !(a.get() < b.get()) && !(b.get() < a.get());
}



template<class T> class type {};



template<class F> struct unwrapper
{
    static inline F & unwrap( F & f, long )
    {
        return f;
    }

    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
    {
        return rf.get();
    }

    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
    {
        return _mfi::dm<R, T>( pm );
    }
};



class list0
{
public:

    list0() {}

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
    {
        return unwrapper<F>::unwrap(f, 0)();
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)();
    }

    template<class F, class A> void operator()(type<void>, F & f, A &, int)
    {
        unwrapper<F>::unwrap(f, 0)();
    }

    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
    {
        unwrapper<F const>::unwrap(f, 0)();
    }

    template<class V> void accept(V &) const
    {
    }

    bool operator==(list0 const &) const
    {
        return true;
    }
};
# 217 "/usr/include/boost-1_42/boost/bind/bind.hpp"
template< class A1 > class list1: private storage1< A1 >
{
private:

    typedef storage1< A1 > base_type;

public:

    explicit list1( A1 a1 ): base_type( a1 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list1 const & rhs) const
    {
        return ref_compare(base_type::a1_, rhs.a1_, 0);
    }
};

struct logical_and;
struct logical_or;

template< class A1, class A2 > class list2: private storage2< A1, A2 >
{
private:

    typedef storage2< A1, A2 > base_type;

public:

    list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class A> bool operator()( type<bool>, logical_and & , A & a, int )
    {
        return a[ base_type::a1_ ] && a[ base_type::a2_ ];
    }

    template<class A> bool operator()( type<bool>, logical_and const & , A & a, int ) const
    {
        return a[ base_type::a1_ ] && a[ base_type::a2_ ];
    }

    template<class A> bool operator()( type<bool>, logical_or & , A & a, int )
    {
        return a[ base_type::a1_ ] || a[ base_type::a2_ ];
    }

    template<class A> bool operator()( type<bool>, logical_or const & , A & a, int ) const
    {
        return a[ base_type::a1_ ] || a[ base_type::a2_ ];
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list2 const & rhs) const
    {
        return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
    }
};

template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
{
private:

    typedef storage3< A1, A2, A3 > base_type;

public:

    list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list3 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 );
    }
};

template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
{
private:

    typedef storage4< A1, A2, A3, A4 > base_type;

public:

    list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list4 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 );
    }
};

template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
{
private:

    typedef storage5< A1, A2, A3, A4, A5 > base_type;

public:

    list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list5 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 );
    }
};

template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
{
private:

    typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;

public:

    list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list6 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 );
    }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >
{
private:

    typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;

public:

    list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list7 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
            ref_compare( base_type::a7_, rhs.a7_, 0 );
    }
};

template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
private:

    typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;

public:

    list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list8 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
            ref_compare( base_type::a8_, rhs.a8_, 0 );
    }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >
{
private:

    typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;

public:

    list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
    A9 operator[] (boost::arg<9>) const { return base_type::a9_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
    A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list9 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
            ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
            ref_compare( base_type::a9_, rhs.a9_, 0 );
    }
};
# 864 "/usr/include/boost-1_42/boost/bind/bind.hpp"
template<class R, class F, class L> class bind_t
{
public:

    typedef bind_t this_type;

    bind_t(F f, L const & l): f_(f), l_(l) {}


# 1 "/usr/include/boost-1_42/boost/bind/bind_template.hpp" 1
# 15 "/usr/include/boost-1_42/boost/bind/bind_template.hpp"
    typedef typename result_traits<R, F>::type result_type;

    result_type operator()()
    {
        list0 a;
        return l_(type<result_type>(), f_, a, 0);
    }

    result_type operator()() const
    {
        list0 a;
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1)
    {
        list1<A1 &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1) const
    {
        list1<A1 &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1> result_type operator()(A1 const & a1)
    {
        list1<A1 const &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 const & a1) const
    {
        list1<A1 const &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
    {
        list2<A1 &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
    {
        list2<A1 &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
    {
        list2<A1 const &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
    {
        list2<A1 const &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
    {
        list2<A1 &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
    {
        list2<A1 &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
    {
        list2<A1 const &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
    {
        list2<A1 const &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A> result_type eval(A & a)
    {
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A> result_type eval(A & a) const
    {
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class V> void accept(V & v) const
    {


        using boost::visit_each;


        visit_each(v, f_, 0);
        l_.accept(v);
    }

    bool compare(this_type const & rhs) const
    {
        return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
    }

private:

    F f_;
    L l_;
# 874 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2


};
# 940 "/usr/include/boost-1_42/boost/bind/bind.hpp"
template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
{
    return a.compare(b);
}
# 994 "/usr/include/boost-1_42/boost/bind/bind.hpp"
template< class T, int I > struct add_value_2
{
    typedef boost::arg<I> type;
};

template< class T > struct add_value_2< T, 0 >
{
    typedef _bi::value< T > type;
};

template<class T> struct add_value
{
    typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
};



template<class T> struct add_value< value<T> >
{
    typedef _bi::value<T> type;
};

template<class T> struct add_value< reference_wrapper<T> >
{
    typedef reference_wrapper<T> type;
};

template<int I> struct add_value< arg<I> >
{
    typedef boost::arg<I> type;
};

template<int I> struct add_value< arg<I> (*) () >
{
    typedef boost::arg<I> (*type) ();
};

template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
{
    typedef bind_t<R, F, L> type;
};
# 1077 "/usr/include/boost-1_42/boost/bind/bind.hpp"
template<class A1> struct list_av_1
{
    typedef typename add_value<A1>::type B1;
    typedef list1<B1> type;
};

template<class A1, class A2> struct list_av_2
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef list2<B1, B2> type;
};

template<class A1, class A2, class A3> struct list_av_3
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef list3<B1, B2, B3> type;
};

template<class A1, class A2, class A3, class A4> struct list_av_4
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef list4<B1, B2, B3, B4> type;
};

template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef list5<B1, B2, B3, B4, B5> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef list6<B1, B2, B3, B4, B5, B6> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef typename add_value<A8>::type B8;
    typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef typename add_value<A8>::type B8;
    typedef typename add_value<A9>::type B9;
    typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
};



struct logical_not
{
    template<class V> bool operator()(V const & v) const { return !v; }
};

template<class R, class F, class L>
    bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
    operator! (bind_t<R, F, L> const & f)
{
    typedef list1< bind_t<R, F, L> > list_type;
    return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
}
# 1200 "/usr/include/boost-1_42/boost/bind/bind.hpp"
struct equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v == w; } }; template<class R, class F, class L, class A2> bind_t< bool, equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator == (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, equal, list_type> ( equal(), list_type(f, a2) ); }
struct not_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v != w; } }; template<class R, class F, class L, class A2> bind_t< bool, not_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator != (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, not_equal, list_type> ( not_equal(), list_type(f, a2) ); }

struct less { template<class V, class W> bool operator()(V const & v, W const & w) const { return v < w; } }; template<class R, class F, class L, class A2> bind_t< bool, less, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator < (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less, list_type> ( less(), list_type(f, a2) ); }
struct less_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v <= w; } }; template<class R, class F, class L, class A2> bind_t< bool, less_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator <= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less_equal, list_type> ( less_equal(), list_type(f, a2) ); }

struct greater { template<class V, class W> bool operator()(V const & v, W const & w) const { return v > w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator > (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater, list_type> ( greater(), list_type(f, a2) ); }
struct greater_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v >= w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator >= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater_equal, list_type> ( greater_equal(), list_type(f, a2) ); }

struct logical_and { template<class V, class W> bool operator()(V const & v, W const & w) const { return v && w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_and, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator && (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_and, list_type> ( logical_and(), list_type(f, a2) ); }
struct logical_or { template<class V, class W> bool operator()(V const & v, W const & w) const { return v || w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_or, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator || (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_or, list_type> ( logical_or(), list_type(f, a2) ); }
# 1240 "/usr/include/boost-1_42/boost/bind/bind.hpp"
template<class V, class T> void visit_each( V & v, value<T> const & t, int )
{
    using boost::visit_each;
    visit_each( v, t.get(), 0 );
}

template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
{
    t.accept( v );
}



}
# 1274 "/usr/include/boost-1_42/boost/bind/bind.hpp"
template< class T > struct is_bind_expression
{
    enum _vt { value = 0 };
};



template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
{
    enum _vt { value = 1 };
};
# 1296 "/usr/include/boost-1_42/boost/bind/bind.hpp"
template<class R, class F>
    _bi::bind_t<R, F, _bi::list0>
    bind(F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class F, class A1>
    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
    bind(F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class F, class A1, class A2>
    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
    bind(F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R, class F, class A1, class A2, class A3>
    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R, class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}



template<class R, class F>
    _bi::bind_t<R, F, _bi::list0>
    bind(boost::type<R>, F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class F, class A1>
    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
    bind(boost::type<R>, F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class F, class A1, class A2>
    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R, class F, class A1, class A2, class A3>
    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R, class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}





template<class F>
    _bi::bind_t<_bi::unspecified, F, _bi::list0>
    bind(F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
}

template<class F, class A1>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
    bind(F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
}

template<class F, class A1, class A2>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
    bind(F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
}

template<class F, class A1, class A2, class A3>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
}

template<class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1549 "/usr/include/boost-1_42/boost/bind/bind.hpp"
# 1 "/usr/include/boost-1_42/boost/bind/bind_cc.hpp" 1
# 15 "/usr/include/boost-1_42/boost/bind/bind_cc.hpp"
template<class R>
    _bi::bind_t<R, R ( *) (), _bi::list0>
    bind( R ( *f) ())
{
    typedef R ( *F) ();
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class B1, class A1>
    _bi::bind_t<R, R ( *) (B1), typename _bi::list_av_1<A1>::type>
    bind( R ( *f) (B1), A1 a1)
{
    typedef R ( *F) (B1);
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class B1, class B2, class A1, class A2>
    _bi::bind_t<R, R ( *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
    bind( R ( *f) (B1, B2), A1 a1, A2 a2)
{
    typedef R ( *F) (B1, B2);
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R,
    class B1, class B2, class B3,
    class A1, class A2, class A3>
    _bi::bind_t<R, R ( *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
    bind( R ( *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
{
    typedef R ( *F) (B1, B2, B3);
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind( R ( *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef R ( *F) (B1, B2, B3, B4);
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef R ( *F) (B1, B2, B3, B4, B5);
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6);
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7);
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8);
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1550 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
# 1595 "/usr/include/boost-1_42/boost/bind/bind.hpp"
# 1 "/usr/include/boost-1_42/boost/bind/bind_mf_cc.hpp" 1
# 17 "/usr/include/boost-1_42/boost/bind/bind_mf_cc.hpp"
template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) (), A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}

template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) () const, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}



template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1), A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}

template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1) const, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}



template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1596 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
# 1 "/usr/include/boost-1_42/boost/bind/bind_mf2_cc.hpp" 1
# 18 "/usr/include/boost-1_42/boost/bind/bind_mf2_cc.hpp"
template<class Rt2, class R, class T,
    class A1>
    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(boost::type<Rt2>, R ( T::*f) (), A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}

template<class Rt2, class R, class T,
    class A1>
    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(boost::type<Rt2>, R ( T::*f) () const, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}



template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1), A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}

template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1) const, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}



template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1597 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
# 1656 "/usr/include/boost-1_42/boost/bind/bind.hpp"
namespace _bi
{

template< class Pm, int I > struct add_cref;

template< class M, class T > struct add_cref< M T::*, 0 >
{
    typedef M type;
};

template< class M, class T > struct add_cref< M T::*, 1 >
{




    typedef M const & type;



};

template< class R, class T > struct add_cref< R (T::*) (), 1 >
{
    typedef void type;
};



template< class R, class T > struct add_cref< R (T::*) () const, 1 >
{
    typedef void type;
};



template<class R> struct isref
{
    enum value_type { value = 0 };
};

template<class R> struct isref< R& >
{
    enum value_type { value = 1 };
};

template<class R> struct isref< R* >
{
    enum value_type { value = 1 };
};

template<class Pm, class A1> struct dm_result
{
    typedef typename add_cref< Pm, 1 >::type type;
};

template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
{
    typedef typename bind_t<R, F, L>::result_type result_type;
    typedef typename add_cref< Pm, isref< result_type >::value >::type type;
};

}

template< class A1, class M, class T >

_bi::bind_t<
    typename _bi::dm_result< M T::*, A1 >::type,
    _mfi::dm<M, T>,
    typename _bi::list_av_1<A1>::type
>

bind( M T::*f, A1 a1 )
{
    typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
    typedef _mfi::dm<M, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
}



}



# 1 "/usr/include/boost-1_42/boost/bind/placeholders.hpp" 1
# 25 "/usr/include/boost-1_42/boost/bind/placeholders.hpp"
namespace
{
# 55 "/usr/include/boost-1_42/boost/bind/placeholders.hpp"
boost::arg<1> _1;
boost::arg<2> _2;
boost::arg<3> _3;
boost::arg<4> _4;
boost::arg<5> _5;
boost::arg<6> _6;
boost::arg<7> _7;
boost::arg<8> _8;
boost::arg<9> _9;



}
# 1743 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
# 23 "/usr/include/boost-1_42/boost/bind.hpp" 2
# 11 "/usr/include/boost-1_42/boost/python/exception_translator.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/detail/translate_exception.hpp" 1







# 1 "/usr/include/boost-1_42/boost/python/detail/exception_handler.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/detail/exception_handler.hpp"
# 1 "/usr/include/boost-1_42/boost/function/function0.hpp" 1
# 11 "/usr/include/boost-1_42/boost/function/function0.hpp"
# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
# 12 "/usr/include/boost-1_42/boost/function/function0.hpp" 2
# 10 "/usr/include/boost-1_42/boost/python/detail/exception_handler.hpp" 2
# 1 "/usr/include/boost-1_42/boost/function/function2.hpp" 1
# 11 "/usr/include/boost-1_42/boost/function/function2.hpp"
# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
# 12 "/usr/include/boost-1_42/boost/function/function2.hpp" 2
# 11 "/usr/include/boost-1_42/boost/python/detail/exception_handler.hpp" 2

namespace boost { namespace python { namespace detail {

struct exception_handler;

typedef function2<bool, exception_handler const&, function0<void> const&> handler_function;

struct exception_handler
{
 private:

 public:
    explicit exception_handler(handler_function const& impl);

    inline bool handle(function0<void> const& f) const;

    bool operator()(function0<void> const& f) const;

    static exception_handler* chain;

 private:
    static exception_handler* tail;

    handler_function m_impl;
    exception_handler* m_next;
};


inline bool exception_handler::handle(function0<void> const& f) const
{
    return this->m_impl(*this, f);
}

 void register_exception_handler(handler_function const& f);

}}}
# 9 "/usr/include/boost-1_42/boost/python/detail/translate_exception.hpp" 2






# 1 "/usr/include/boost-1_42/boost/function/function0.hpp" 1
# 11 "/usr/include/boost-1_42/boost/function/function0.hpp"
# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
# 12 "/usr/include/boost-1_42/boost/function/function0.hpp" 2
# 16 "/usr/include/boost-1_42/boost/python/detail/translate_exception.hpp" 2

namespace boost { namespace python { namespace detail {





template <class ExceptionType, class Translate>
struct translate_exception
{
# 36 "/usr/include/boost-1_42/boost/python/detail/translate_exception.hpp"
    typedef typename add_reference<
        typename add_const<ExceptionType>::type
    >::type exception_cref;


    inline bool operator()(
        exception_handler const& handler
      , function0<void> const& f
      , typename call_traits<Translate>::param_type translate) const
    {
        try
        {
            return handler(f);
        }
# 58 "/usr/include/boost-1_42/boost/python/detail/translate_exception.hpp"
        catch(exception_cref e)

        {
            translate(e);
            return true;
        }
    }
};

}}}
# 13 "/usr/include/boost-1_42/boost/python/exception_translator.hpp" 2


namespace boost { namespace python {

template <class ExceptionType, class Translate>
void register_exception_translator(Translate translate, boost::type<ExceptionType>* = 0)
{
    detail::register_exception_handler(
        bind<bool>(detail::translate_exception<ExceptionType,Translate>(), _1, _2, translate)
        );
}

}}
# 29 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/exec.hpp" 1
# 9 "/usr/include/boost-1_42/boost/python/exec.hpp"
# 1 "/usr/include/boost-1_42/boost/python/str.hpp" 1
# 22 "/usr/include/boost-1_42/boost/python/str.hpp"
namespace boost { namespace python {

class str;

namespace detail
{
  struct str_base : object
  {
      str capitalize() const;

      str center(object_cref width) const;

      long count(object_cref sub) const;

      long count(object_cref sub, object_cref start) const;

      long count(object_cref sub, object_cref start, object_cref end) const;


      object decode() const;
      object decode(object_cref encoding) const;

      object decode(object_cref encoding, object_cref errors) const;


      object encode() const;
      object encode(object_cref encoding) const;
      object encode(object_cref encoding, object_cref errors) const;

      bool endswith(object_cref suffix) const;

      bool endswith(object_cref suffix, object_cref start) const;
      bool endswith(object_cref suffix, object_cref start, object_cref end) const;

      str expandtabs() const;
      str expandtabs(object_cref tabsize) const;

      long find(object_cref sub) const;
      long find(object_cref sub, object_cref start) const;

      long find(object_cref sub, object_cref start, object_cref end) const;

      long index(object_cref sub) const;

      long index(object_cref sub, object_cref start) const;
      long index(object_cref sub, object_cref start, object_cref end) const;

      bool isalnum() const;
      bool isalpha() const;
      bool isdigit() const;
      bool islower() const;
      bool isspace() const;
      bool istitle() const;
      bool isupper() const;

      str join(object_cref sequence) const;

      str ljust(object_cref width) const;
      str lower() const;
      str lstrip() const;

      str replace(object_cref old, object_cref new_) const;
      str replace(object_cref old, object_cref new_, object_cref maxsplit) const;
      long rfind(object_cref sub) const;

      long rfind(object_cref sub, object_cref start) const;

      long rfind(object_cref sub, object_cref start, object_cref end) const;
      long rindex(object_cref sub) const;
      long rindex(object_cref sub, object_cref start) const;


      long rindex(object_cref sub, object_cref start, object_cref end) const;

      str rjust(object_cref width) const;

      str rstrip() const;

      list split() const;
      list split(object_cref sep) const;

      list split(object_cref sep, object_cref maxsplit) const;


      list splitlines() const;
      list splitlines(object_cref keepends) const;

      bool startswith(object_cref prefix) const;


      bool startswith(object_cref prefix, object_cref start) const;
      bool startswith(object_cref prefix, object_cref start, object_cref end) const;

      str strip() const;
      str swapcase() const;
      str title() const;

      str translate(object_cref table) const;

      str translate(object_cref table, object_cref deletechars) const;


      str upper() const;

   protected:
      str_base();

      str_base(const char* s);

      str_base(char const* start, char const* finish);

      str_base(char const* start, std::size_t length);

      explicit str_base(object_cref other);

      inline explicit str_base(python::detail::borrowed_reference p) : object(p) {} inline explicit str_base(python::detail::new_reference p) : object(p) {} inline explicit str_base(python::detail::new_non_null_reference p) : object(p) {}
   private:
      static new_reference call(object const&);
  };
}


class str : public detail::str_base
{
    typedef detail::str_base base;
 public:
    str() {}

    str(const char* s) : base(s) {}

    str(char const* start, char const* finish)
      : base(start, finish)
    {}

    str(char const* start, std::size_t length)
      : base(start, length)
    {}

    template <class T>
    explicit str(T const& other)
        : base(object(other))
    {
    }

    template <class T>
    str center(T const& width) const
    {
        return base::center(object(width));
    }

    template<class T>
    long count(T const& sub) const
    {
        return base::count(object(sub));
    }

    template<class T1, class T2>
    long count(T1 const& sub,T2 const& start) const
    {
        return base::count(object(sub), object(start));
    }

    template<class T1, class T2, class T3>
    long count(T1 const& sub,T2 const& start, T3 const& end) const
    {
        return base::count(object(sub), object(start));
    }


    object decode() const { return base::decode(); }

    template<class T>
    object decode(T const& encoding) const
    {
        return base::decode(object(encoding));
    }

    template<class T1, class T2>
    object decode(T1 const& encoding, T2 const& errors) const
    {
        return base::decode(object(encoding),object(errors));
    }


    object encode() const { return base::encode(); }

    template <class T>
    object encode(T const& encoding) const
    {
        return base::encode(object(encoding));
    }

    template <class T1, class T2>
    object encode(T1 const& encoding, T2 const& errors) const
    {
        return base::encode(object(encoding),object(errors));
    }

    template <class T>
    bool endswith(T const& suffix) const
    {
        return base::endswith(object(suffix));
    }

    template <class T1, class T2>
    bool endswith(T1 const& suffix, T2 const& start) const
    {
        return base::endswith(object(suffix), object(start));
    }

    template <class T1, class T2, class T3>
    bool endswith(T1 const& suffix, T2 const& start, T3 const& end) const
    {
        return base::endswith(object(suffix), object(start), object(end));
    }

    str expandtabs() const { return base::expandtabs(); }

    template <class T>
    str expandtabs(T const& tabsize) const
    {
        return base::expandtabs(object(tabsize));
    }

    template <class T>
    long find(T const& sub) const
    {
        return base::find(object(sub));
    }

    template <class T1, class T2>
    long find(T1 const& sub, T2 const& start) const
    {
        return base::find(object(sub), object(start));
    }

    template <class T1, class T2, class T3>
    long find(T1 const& sub, T2 const& start, T3 const& end) const
    {
        return base::find(object(sub), object(start), object(end));
    }

    template <class T>
    long index(T const& sub) const
    {
        return base::index(object(sub));
    }

    template <class T1, class T2>
    long index(T1 const& sub, T2 const& start) const
    {
        return base::index(object(sub), object(start));
    }

    template <class T1, class T2, class T3>
    long index(T1 const& sub, T2 const& start, T3 const& end) const
    {
        return base::index(object(sub), object(start), object(end));
    }

    template <class T>
    str join(T const& sequence) const
    {
        return base::join(object(sequence));
    }

    template <class T>
    str ljust(T const& width) const
    {
        return base::ljust(object(width));
    }

    template <class T1, class T2>
    str replace(T1 const& old, T2 const& new_) const
    {
        return base::replace(object(old),object(new_));
    }

    template <class T1, class T2, class T3>
    str replace(T1 const& old, T2 const& new_, T3 const& maxsplit) const
    {
        return base::replace(object(old),object(new_), object(maxsplit));
    }

    template <class T>
    long rfind(T const& sub) const
    {
        return base::rfind(object(sub));
    }

    template <class T1, class T2>
    long rfind(T1 const& sub, T2 const& start) const
    {
        return base::rfind(object(sub), object(start));
    }

    template <class T1, class T2, class T3>
    long rfind(T1 const& sub, T2 const& start, T3 const& end) const
    {
        return base::rfind(object(sub), object(start), object(end));
    }

    template <class T>
    long rindex(T const& sub) const
    {
        return base::rindex(object(sub));
    }

    template <class T1, class T2>
    long rindex(T1 const& sub, T2 const& start) const
    {
        return base::rindex(object(sub), object(start));
    }

    template <class T1, class T2, class T3>
    long rindex(T1 const& sub, T2 const& start, T3 const& end) const
    {
        return base::rindex(object(sub), object(start), object(end));
    }

    template <class T>
    str rjust(T const& width) const
    {
        return base::rjust(object(width));
    }

    list split() const { return base::split(); }

    template <class T>
    list split(T const& sep) const
    {
        return base::split(object(sep));
    }

    template <class T1, class T2>
    list split(T1 const& sep, T2 const& maxsplit) const
    {
        return base::split(object(sep), object(maxsplit));
    }

    list splitlines() const { return base::splitlines(); }

    template <class T>
    list splitlines(T const& keepends) const
    {
        return base::splitlines(object(keepends));
    }

    template <class T>
    bool startswith(T const& prefix) const
    {
        return base::startswith(object(prefix));
    }

    template <class T1, class T2>
    bool startswith(T1 const& prefix, T2 const& start) const
    {
        return base::startswith(object(prefix), object(start));
    }

    template <class T1, class T2, class T3>
    bool startswith(T1 const& prefix, T2 const& start, T3 const& end) const
    {
        return base::startswith(object(prefix), object(start), object(end));
    }

    template <class T>
    str translate(T const& table) const
    {
        return base::translate(object(table));
    }

    template <class T1, class T2>
    str translate(T1 const& table, T2 const& deletechars) const
    {
        return base::translate(object(table), object(deletechars));
    }

 public:
    inline explicit str(python::detail::borrowed_reference p) : base(p) {} inline explicit str(python::detail::new_reference p) : base(p) {} inline explicit str(python::detail::new_non_null_reference p) : base(p) {}
};




namespace converter
{
  template <>
  struct object_manager_traits<str>



      : pytype_object_manager_traits<&PyString_Type,str>

  {
  };
}

}}
# 10 "/usr/include/boost-1_42/boost/python/exec.hpp" 2

namespace boost
{
namespace python
{




object

eval(str string, object global = object(), object local = object());




object

exec_statement(str string, object global = object(), object local = object());




object

exec(str string, object global = object(), object local = object());




object

exec_file(str filename, object global = object(), object local = object());

}
}
# 30 "/usr/include/boost-1_42/boost/python.hpp" 2



# 1 "/usr/include/boost-1_42/boost/python/implicit.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/implicit.hpp"
# 1 "/usr/include/boost-1_42/boost/python/converter/implicit.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/converter/implicit.hpp"
namespace boost { namespace python { namespace converter {

template <class Source, class Target>
struct implicit
{
    static void* convertible(PyObject* obj)
    {




        return implicit_rvalue_convertible_from_python(obj, registered<Source>::converters)
            ? obj : 0;
    }

    static void construct(PyObject* obj, rvalue_from_python_stage1_data* data)
    {
        void* storage = ((rvalue_from_python_storage<Target>*)data)->storage.bytes;

        arg_from_python<Source> get_source(obj);
        bool convertible = get_source.convertible();
        ((void)(convertible));

        new (storage) Target(get_source());


        data->convertible = storage;
    }
};

}}}
# 11 "/usr/include/boost-1_42/boost/python/implicit.hpp" 2






namespace boost { namespace python {

template <class Source, class Target>
void implicitly_convertible(boost::type<Source>* = 0, boost::type<Target>* = 0)
{
    typedef converter::implicit<Source,Target> functions;

    converter::registry::push_back(
          &functions::convertible
        , &functions::construct
        , type_id<Target>()

        , &converter::expected_from_python_type_direct<Source>::get_pytype

        );
}

}}
# 34 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/import.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/import.hpp"
namespace boost
{
namespace python
{


object import(str name);

}
}
# 36 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/iterator.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/iterator.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 22 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
namespace boost { namespace python { namespace detail {



# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R >
void(* target(R (*)()) )()
{
    return 0;
}
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0>
A0(* target(R (*)( A0)) )()
{
    return 0;
}
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1>
A0(* target(R (*)( A0 , A1)) )()
{
    return 0;
}
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2>
A0(* target(R (*)( A0 , A1 , A2)) )()
{
    return 0;
}
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3>
A0(* target(R (*)( A0 , A1 , A2 , A3)) )()
{
    return 0;
}
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4)) )()
{
    return 0;
}
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5)) )()
{
    return 0;
}
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6)) )()
{
    return 0;
}
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)) )()
{
    return 0;
}
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)) )()
{
    return 0;
}
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)) )()
{
    return 0;
}
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10)) )()
{
    return 0;
}
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11)) )()
{
    return 0;
}
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12)) )()
{
    return 0;
}
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13)) )()
{
    return 0;
}
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"




template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14)) )()
{
    return 0;
}
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2



# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 64 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T >
T& (* target(R (T::*)() ) )()
{
    return 0;
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0>
T& (* target(R (T::*)( A0) ) )()
{
    return 0;
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1>
T& (* target(R (T::*)( A0 , A1) ) )()
{
    return 0;
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2>
T& (* target(R (T::*)( A0 , A1 , A2) ) )()
{
    return 0;
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3>
T& (* target(R (T::*)( A0 , A1 , A2 , A3) ) )()
{
    return 0;
}
# 66 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4) ) )()
{
    return 0;
}
# 71 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5) ) )()
{
    return 0;
}
# 76 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6) ) )()
{
    return 0;
}
# 81 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) ) )()
{
    return 0;
}
# 86 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) ) )()
{
    return 0;
}
# 91 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) ) )()
{
    return 0;
}
# 96 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10) ) )()
{
    return 0;
}
# 101 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11) ) )()
{
    return 0;
}
# 106 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12) ) )()
{
    return 0;
}
# 111 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13) ) )()
{
    return 0;
}
# 116 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14) ) )()
{
    return 0;
}
# 121 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 65 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 64 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T >
T& (* target(R (T::*)() const) )()
{
    return 0;
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0>
T& (* target(R (T::*)( A0) const) )()
{
    return 0;
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1>
T& (* target(R (T::*)( A0 , A1) const) )()
{
    return 0;
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2>
T& (* target(R (T::*)( A0 , A1 , A2) const) )()
{
    return 0;
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3>
T& (* target(R (T::*)( A0 , A1 , A2 , A3) const) )()
{
    return 0;
}
# 66 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4) const) )()
{
    return 0;
}
# 71 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5) const) )()
{
    return 0;
}
# 76 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6) const) )()
{
    return 0;
}
# 81 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) const) )()
{
    return 0;
}
# 86 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) const) )()
{
    return 0;
}
# 91 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) const) )()
{
    return 0;
}
# 96 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10) const) )()
{
    return 0;
}
# 101 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11) const) )()
{
    return 0;
}
# 106 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12) const) )()
{
    return 0;
}
# 111 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13) const) )()
{
    return 0;
}
# 116 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14) const) )()
{
    return 0;
}
# 121 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 65 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 64 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T >
T& (* target(R (T::*)() volatile) )()
{
    return 0;
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0>
T& (* target(R (T::*)( A0) volatile) )()
{
    return 0;
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1>
T& (* target(R (T::*)( A0 , A1) volatile) )()
{
    return 0;
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2>
T& (* target(R (T::*)( A0 , A1 , A2) volatile) )()
{
    return 0;
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3>
T& (* target(R (T::*)( A0 , A1 , A2 , A3) volatile) )()
{
    return 0;
}
# 66 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4) volatile) )()
{
    return 0;
}
# 71 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5) volatile) )()
{
    return 0;
}
# 76 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6) volatile) )()
{
    return 0;
}
# 81 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) volatile) )()
{
    return 0;
}
# 86 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) volatile) )()
{
    return 0;
}
# 91 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) volatile) )()
{
    return 0;
}
# 96 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10) volatile) )()
{
    return 0;
}
# 101 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11) volatile) )()
{
    return 0;
}
# 106 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12) volatile) )()
{
    return 0;
}
# 111 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13) volatile) )()
{
    return 0;
}
# 116 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14) volatile) )()
{
    return 0;
}
# 121 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 65 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 64 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T >
T& (* target(R (T::*)() const volatile) )()
{
    return 0;
}
# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0>
T& (* target(R (T::*)( A0) const volatile) )()
{
    return 0;
}
# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1>
T& (* target(R (T::*)( A0 , A1) const volatile) )()
{
    return 0;
}
# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2>
T& (* target(R (T::*)( A0 , A1 , A2) const volatile) )()
{
    return 0;
}
# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3>
T& (* target(R (T::*)( A0 , A1 , A2 , A3) const volatile) )()
{
    return 0;
}
# 66 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4) const volatile) )()
{
    return 0;
}
# 71 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5) const volatile) )()
{
    return 0;
}
# 76 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6) const volatile) )()
{
    return 0;
}
# 81 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) const volatile) )()
{
    return 0;
}
# 86 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) const volatile) )()
{
    return 0;
}
# 91 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) const volatile) )()
{
    return 0;
}
# 96 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10) const volatile) )()
{
    return 0;
}
# 101 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11) const volatile) )()
{
    return 0;
}
# 106 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12) const volatile) )()
{
    return 0;
}
# 111 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13) const volatile) )()
{
    return 0;
}
# 116 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"






template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14) const volatile) )()
{
    return 0;
}
# 121 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
# 65 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 31 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2

template <class R, class T>
T& (* target(R (T::*)) )() { return 0; }

}}}
# 11 "/usr/include/boost-1_42/boost/python/iterator.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/iterator.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/object/iterator.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/iterator_core.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/object/iterator_core.hpp"
namespace boost { namespace python { namespace objects {

 object const& identity_function();
 void stop_iteration_error();

}}}
# 17 "/usr/include/boost-1_42/boost/python/object/iterator.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/class_detail.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/object/class_detail.hpp"
namespace boost { namespace python { namespace objects {

 type_handle registered_class_object(type_info id);
 type_handle class_metatype();
 type_handle class_type();

}}}
# 18 "/usr/include/boost-1_42/boost/python/object/iterator.hpp" 2
# 31 "/usr/include/boost-1_42/boost/python/object/iterator.hpp"
# 1 "/usr/include/boost-1_42/boost/detail/iterator.hpp" 1
# 77 "/usr/include/boost-1_42/boost/detail/iterator.hpp"
namespace boost { namespace detail {


template <class Iterator>
struct iterator_traits
    : std::iterator_traits<Iterator>
{};
using std::distance;

}}
# 32 "/usr/include/boost-1_42/boost/python/object/iterator.hpp" 2

namespace boost { namespace python { namespace objects {






typedef return_value_policy<return_by_value> default_iterator_call_policies;


template <class NextPolicies, class Iterator>
struct iterator_range
{
    iterator_range(object sequence, Iterator start, Iterator finish);

    typedef boost::detail::iterator_traits<Iterator> traits_t;

    struct next
    {
        typedef typename mpl::if_<
            is_reference<
                typename traits_t::reference
            >
          , typename traits_t::reference
          , typename traits_t::value_type
        >::type result_type;

        result_type
        operator()(iterator_range<NextPolicies,Iterator>& self)
        {
            if (self.m_start == self.m_finish)
                stop_iteration_error();
            return *self.m_start++;
        }





    };
# 101 "/usr/include/boost-1_42/boost/python/object/iterator.hpp"
    typedef next next_fn;


    object m_sequence;
    Iterator m_start;
    Iterator m_finish;
};

namespace detail
{



  template <class Iterator, class NextPolicies>
  object demand_iterator_class(char const* name, Iterator* = 0, NextPolicies const& policies = NextPolicies())
  {
      typedef iterator_range<NextPolicies,Iterator> range_;


      handle<> class_obj(
          objects::registered_class_object(python::type_id<range_>()));

      if (class_obj.get() != 0)
          return object(class_obj);

      typedef typename range_::next_fn next_fn;
      typedef typename next_fn::result_type result_type;

      return class_<range_>(name, no_init)
          .def("__iter__", identity_function())
          .def(



              "next"

            , make_function(
                next_fn()
              , policies
              , mpl::vector2<result_type,range_&>()
            ));
  }


  template <
      class Target
    , class Iterator
    , class Accessor1
    , class Accessor2
    , class NextPolicies
  >
  struct py_iter_
  {
      py_iter_(Accessor1 const& get_start, Accessor2 const& get_finish)
        : m_get_start(get_start)
        , m_get_finish(get_finish)
      {}





      iterator_range<NextPolicies,Iterator>
      operator()(back_reference<Target&> x) const
      {

          detail::demand_iterator_class("iterator", (Iterator*)0, NextPolicies());

          return iterator_range<NextPolicies,Iterator>(
              x.source()
            , m_get_start(x.get())
            , m_get_finish(x.get())
          );
      }
   private:
      Accessor1 m_get_start;
      Accessor2 m_get_finish;
  };

  template <class Target, class Iterator, class NextPolicies, class Accessor1, class Accessor2>
  inline object make_iterator_function(
      Accessor1 const& get_start
    , Accessor2 const& get_finish
    , NextPolicies const&
    , Iterator const& (*)()
    , boost::type<Target>*
    , int
  )
  {
      return make_function(
          py_iter_<Target,Iterator,Accessor1,Accessor2,NextPolicies>(get_start, get_finish)
        , default_call_policies()
        , mpl::vector2<iterator_range<NextPolicies,Iterator>, back_reference<Target&> >()
      );
  }

  template <class Target, class Iterator, class NextPolicies, class Accessor1, class Accessor2>
  inline object make_iterator_function(
      Accessor1 const& get_start
    , Accessor2 const& get_finish
    , NextPolicies const& next_policies
    , Iterator& (*)()
    , boost::type<Target>*
    , ...)
  {
      return make_iterator_function(
          get_start
        , get_finish
        , next_policies
        , (Iterator const&(*)())0
        , (boost::type<Target>*)0
        , 0
      );
  }

}







template <class Target, class NextPolicies, class Accessor1, class Accessor2>
inline object make_iterator_function(
    Accessor1 const& get_start
  , Accessor2 const& get_finish
  , NextPolicies const& next_policies
  , boost::type<Target>* = 0
)
{
    typedef typename Accessor1::result_type iterator;
    typedef typename add_const<iterator>::type iterator_const;
    typedef typename add_reference<iterator_const>::type iterator_cref;

    return detail::make_iterator_function(
        get_start
      , get_finish
      , next_policies
      , (iterator_cref(*)())0
      , (boost::type<Target>*)0
      , 0
    );
}




template <class NextPolicies, class Iterator>
inline iterator_range<NextPolicies,Iterator>::iterator_range(
    object sequence, Iterator start, Iterator finish)
    : m_sequence(sequence), m_start(start), m_finish(finish)
{
}

}}}
# 12 "/usr/include/boost-1_42/boost/python/iterator.hpp" 2
# 28 "/usr/include/boost-1_42/boost/python/iterator.hpp"
# 1 "/usr/include/boost-1_42/boost/bind/protect.hpp" 1
# 18 "/usr/include/boost-1_42/boost/bind/protect.hpp"
namespace boost
{

namespace _bi
{

template<class F> class protected_bind_t
{
public:

    typedef typename F::result_type result_type;

    explicit protected_bind_t(F f): f_(f)
    {
    }

    result_type operator()()
    {
        return f_();
    }

    result_type operator()() const
    {
        return f_();
    }

    template<class A1> result_type operator()(A1 & a1)
    {
        return f_(a1);
    }

    template<class A1> result_type operator()(A1 & a1) const
    {
        return f_(a1);
    }





    template<class A1> result_type operator()(const A1 & a1)
    {
        return f_(a1);
    }

    template<class A1> result_type operator()(const A1 & a1) const
    {
        return f_(a1);
    }



    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
    {
        return f_(a1, a2);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
    {
        return f_(a1, a2);
    }




    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
    {
        return f_(a1, a2);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
    {
        return f_(a1, a2);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
    {
        return f_(a1, a2);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
    {
        return f_(a1, a2);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
    {
        return f_(a1, a2);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
    {
        return f_(a1, a2);
    }



    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
    {
        return f_(a1, a2, a3);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
    {
        return f_(a1, a2, a3);
    }




    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
    {
        return f_(a1, a2, a3);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
    {
        return f_(a1, a2, a3);
    }



    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
    {
        return f_(a1, a2, a3, a4);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
    {
        return f_(a1, a2, a3, a4);
    }




    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
    {
        return f_(a1, a2, a3, a4);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
    {
        return f_(a1, a2, a3, a4);
    }



    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
    {
        return f_(a1, a2, a3, a4, a5);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
    {
        return f_(a1, a2, a3, a4, a5);
    }




    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
    {
        return f_(a1, a2, a3, a4, a5);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
    {
        return f_(a1, a2, a3, a4, a5);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
    {
        return f_(a1, a2, a3, a4, a5, a6);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
    {
        return f_(a1, a2, a3, a4, a5, a6);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
    {
        return f_(a1, a2, a3, a4, a5, a6);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
    {
        return f_(a1, a2, a3, a4, a5, a6);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
    {
        return f_(a1, a2, a3, a4, a5, a6, a7);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
    {
        return f_(a1, a2, a3, a4, a5, a6, a7);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
    {
        return f_(a1, a2, a3, a4, a5, a6, a7);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
    {
        return f_(a1, a2, a3, a4, a5, a6, a7);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
    {
        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
    {
        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
    {
        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
    {
        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
    {
        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
    {
        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
    {
        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
    {
        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
    }



private:

    F f_;
};

}

template<class F> _bi::protected_bind_t<F> protect(F f)
{
    return _bi::protected_bind_t<F>(f);
}

}
# 29 "/usr/include/boost-1_42/boost/python/iterator.hpp" 2

namespace boost { namespace python {

namespace detail
{



  template <class Target, class Accessor1, class Accessor2, class NextPolicies>
  inline object make_iterator(
      Accessor1 get_start
    , Accessor2 get_finish
    , NextPolicies next_policies
    , Target&(*)()
  )
  {
      return objects::make_iterator_function<Target>(
          boost::protect(boost::bind(get_start, _1))
        , boost::protect(boost::bind(get_finish, _1))
        , next_policies
      );
  }


  template <bool const_ = false>
  struct iterators_impl
  {
      template <class T>
      struct apply
      {
          typedef typename T::iterator iterator;
          static iterator begin(T& x) { return x.begin(); }
          static iterator end(T& x) { return x.end(); }
      };
  };

  template <>
  struct iterators_impl<true>
  {
      template <class T>
      struct apply
      {
          typedef typename T::const_iterator iterator;
          static iterator begin(T& x) { return x.begin(); }
          static iterator end(T& x) { return x.end(); }
      };
  };
}



template <class T>
struct iterators
    : detail::iterators_impl<
        boost::is_const<T>::value
      >::template apply<T>
{
};




template <class Accessor1, class Accessor2>
object range(Accessor1 start, Accessor2 finish)
{
    return detail::make_iterator(
        start, finish
      , objects::default_iterator_call_policies()
      , detail::target(start)
    );
}



template <class NextPolicies, class Accessor1, class Accessor2>
object range(Accessor1 start, Accessor2 finish, NextPolicies* = 0)
{
    return detail::make_iterator(start, finish, NextPolicies(), detail::target(start));
}



template <class NextPolicies, class Target, class Accessor1, class Accessor2>
object range(Accessor1 start, Accessor2 finish, NextPolicies* = 0, boost::type<Target>* = 0)
{

    return detail::make_iterator(start, finish, NextPolicies(), (Target&(*)())0);
}





template <class Container
          , class NextPolicies = objects::default_iterator_call_policies>
struct iterator : object
{
    iterator()
        : object(
            python::range<NextPolicies>(
                &iterators<Container>::begin, &iterators<Container>::end
                ))
    {
    }
};

}}
# 38 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/long.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/long.hpp"
namespace boost { namespace python {

namespace detail
{
  struct long_base : object
  {
   protected:
      long_base();
      explicit long_base(object_cref rhs);
      explicit long_base(object_cref rhs, object_cref base);

      inline explicit long_base(python::detail::borrowed_reference p) : object(p) {} inline explicit long_base(python::detail::new_reference p) : object(p) {} inline explicit long_base(python::detail::new_non_null_reference p) : object(p) {}

   private:
      static detail::new_non_null_reference call(object const&);
      static detail::new_non_null_reference call(object const&, object const&);
  };
}

class long_ : public detail::long_base
{
    typedef detail::long_base base;
 public:
    long_() {}

    template <class T>
    explicit long_(T const& rhs)
        : detail::long_base(object(rhs))
    {
    }

    template <class T, class U>
    explicit long_(T const& rhs, U const& base)
        : detail::long_base(object(rhs), object(base))
    {
    }

 public:
    inline explicit long_(python::detail::borrowed_reference p) : base(p) {} inline explicit long_(python::detail::new_reference p) : base(p) {} inline explicit long_(python::detail::new_non_null_reference p) : base(p) {}
};




namespace converter
{
  template <>
  struct object_manager_traits<long_>
      : pytype_object_manager_traits<&PyLong_Type,long_>
  {
  };
}

}}
# 40 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/lvalue_from_pytype.hpp" 1
# 17 "/usr/include/boost-1_42/boost/python/lvalue_from_pytype.hpp"
namespace boost { namespace python {

namespace detail
{


  template <class T, class U>
  inline type_info extractor_type_id(T&(*)(U))
  {
      return type_id<T>();
  }





  template <class Extractor, class U>
  struct normalized_extractor
  {
      static inline void* execute(PyObject* op)
      {
          typedef typename boost::add_reference<U>::type param;
          return &Extractor::execute(
              boost::python::detail::void_ptr_to_reference(
                  op, (param(*)())0 )
              );
      }
  };






  template <class Extractor, class T, class U>
  inline normalized_extractor<Extractor,U>
  normalize(T(*)(U), Extractor* = 0)
  {
      return normalized_extractor<Extractor, U>();
  }
}



template <class InstanceType, class MemberType, MemberType (InstanceType::*member)>
struct extract_member
{
    static MemberType& execute(InstanceType& c)
    {
        (void)(((PyObject*)(&c))->ob_type);
        return c.*member;
    }
};



template <class InstanceType>
struct extract_identity
{
    static InstanceType& execute(InstanceType& c)
    {
        (void)(((PyObject*)(&c))->ob_type);
        return c;
    }
};




template <class Extractor, PyTypeObject const* python_type>
struct lvalue_from_pytype
{
    lvalue_from_pytype()
    {
        converter::registry::insert
            ( &extract
            , detail::extractor_type_id(&Extractor::execute)

            , &get_pytype

            );
    }
 private:
    static void* extract(PyObject* op)
    {
        return ((((PyObject*)(op))->ob_type) == (const_cast<PyTypeObject*>(python_type)) || PyType_IsSubtype((((PyObject*)(op))->ob_type), (const_cast<PyTypeObject*>(python_type))))
            ? const_cast<void*>(
                static_cast<void const volatile*>(
                    detail::normalize<Extractor>(&Extractor::execute).execute(op)))
            : 0
            ;
    }

    static PyTypeObject const*get_pytype() { return python_type; }

};

}}
# 41 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 1
# 15 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
# 17 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 2


# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
# 20 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 2




# 1 "/usr/include/boost-1_42/boost/mpl/push_front.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/push_front.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/push_front_impl.hpp" 1
# 26 "/usr/include/boost-1_42/boost/mpl/aux_/push_front_impl.hpp"
namespace boost { namespace mpl {

struct has_push_front_arg {};




template< typename Tag >
struct push_front_impl
{
    template< typename Sequence, typename T > struct apply
    {



        struct REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST; typedef struct



 REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST45
# 41 "/usr/include/boost-1_42/boost/mpl/aux_/push_front_impl.hpp"
        : boost::mpl::assert_ { static boost::mpl::failed ************ (REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST::************ assert_arg()) ( Sequence ) { return 0; } }



 mpl_assert_arg45
# 41 "/usr/include/boost-1_42/boost/mpl/aux_/push_front_impl.hpp"
        ; enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<(( boost::is_same< T, has_push_front_arg >::value ))>( mpl_assert_arg45::assert_arg() ) ) }



             ;
    };
};

template< typename Tag >
struct has_push_front_impl
{
    template< typename Seq > struct apply

        : aux::has_type< push_front< Seq, has_push_front_arg > >
    {







    };
};

 template<> struct push_front_impl<non_sequence_tag> {};
 template<> struct has_push_front_impl<non_sequence_tag> {};

}}
# 19 "/usr/include/boost-1_42/boost/mpl/push_front.hpp" 2




namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename T = na
    >
struct push_front
    : push_front_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,T >
{
   
};


template<
      typename Sequence = na
    >
struct has_push_front
    : has_push_front_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct push_front< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : push_front< T1 , T2 > { }; }; template< typename Tag > struct lambda< push_front< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef push_front< na , na > result_; typedef push_front< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< push_front< T1 , T2 > > : int_<2> { }; template<> struct template_arity< push_front< na , na > > : int_<-1> { }; }
template<> struct has_push_front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_push_front< T1 > { }; }; template< typename Tag > struct lambda< has_push_front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_push_front< na > result_; typedef has_push_front< na > type; }; namespace aux { template< typename T1 > struct template_arity< has_push_front< T1 > > : int_<1> { }; template<> struct template_arity< has_push_front< na > > : int_<-1> { }; }

}}
# 25 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/pop_front.hpp" 1
# 18 "/usr/include/boost-1_42/boost/mpl/pop_front.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/pop_front_impl.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/pop_front_impl.hpp"
namespace boost { namespace mpl {



template< typename Tag >
struct pop_front_impl
{
    template< typename Sequence > struct apply







    ;
};

 template<> struct pop_front_impl<non_sequence_tag> {};

}}
# 19 "/usr/include/boost-1_42/boost/mpl/pop_front.hpp" 2




namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct pop_front
    : pop_front_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct pop_front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pop_front< T1 > { }; }; template< typename Tag > struct lambda< pop_front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef pop_front< na > result_; typedef pop_front< na > type; }; namespace aux { template< typename T1 > struct template_arity< pop_front< T1 > > : int_<1> { }; template<> struct template_arity< pop_front< na > > : int_<-1> { }; }

}}
# 26 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 2


namespace boost { namespace python {

namespace detail
{
  template <class T>
  struct install_holder : converter::context_result_converter
  {
      install_holder(PyObject* args_)
        : m_self(PyTuple_GetItem(args_, 0)) {}

      PyObject* operator()(T x) const
      {
          dispatch(x, is_pointer<T>());
          return none();
      }

   private:
      template <class U>
      void dispatch(U* x, mpl::true_) const
      {
          std::auto_ptr<U> owner(x);
          dispatch(owner, mpl::false_());
      }

      template <class Ptr>
      void dispatch(Ptr x, mpl::false_) const
      {
          typedef typename pointee<Ptr>::type value_type;
          typedef objects::pointer_holder<Ptr,value_type> holder;
          typedef objects::instance<holder> instance_t;

          void* memory = holder::allocate(this->m_self, __builtin_offsetof (instance_t, storage), sizeof(holder));
          try {
              (new (memory) holder(x))->install(this->m_self);
          }
          catch(...) {
              holder::deallocate(this->m_self, memory);
              throw;
          }
      }

      PyObject* m_self;
  };

  struct constructor_result_converter
  {
      template <class T>
      struct apply
      {
          typedef install_holder<T> type;
      };
  };

  template <class BaseArgs, class Offset>
  struct offset_args
  {
      offset_args(BaseArgs base_) : base(base_) {}
      BaseArgs base;
  };

  template <int N, class BaseArgs, class Offset>
  inline PyObject* get(mpl::int_<N>, offset_args<BaseArgs,Offset> const& args_)
  {
      return get(mpl::int_<(N+Offset::value)>(), args_.base);
  }

  template <class BaseArgs, class Offset>
  inline unsigned arity(offset_args<BaseArgs,Offset> const& args_)
  {
      return arity(args_.base) - Offset::value;
  }

  template <class BasePolicy_ = default_call_policies>
  struct constructor_policy : BasePolicy_
  {
      constructor_policy(BasePolicy_ base) : BasePolicy_(base) {}
# 115 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
      struct MAKE_CONSTRUCTOR_SUPPLIES_ITS_OWN_RESULT_CONVERTER_THAT_WOULD_OVERRIDE_YOURS; typedef struct






 MAKE_CONSTRUCTOR_SUPPLIES_ITS_OWN_RESULT_CONVERTER_THAT_WOULD_OVERRIDE_YOURS122
# 115 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
      : boost::mpl::assert_ { static boost::mpl::failed ************ (MAKE_CONSTRUCTOR_SUPPLIES_ITS_OWN_RESULT_CONVERTER_THAT_WOULD_OVERRIDE_YOURS::************ assert_arg()) (typename BasePolicy_::result_converter) { return 0; } }






 mpl_assert_arg122
# 115 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
      ; enum { mpl_assertion_in_line_122 = sizeof( boost::mpl::assertion_failed<((is_same< typename BasePolicy_::result_converter , default_result_converter >::value))>( mpl_assert_arg122::assert_arg() ) ) }






       ;

      typedef constructor_result_converter result_converter;
      typedef offset_args<typename BasePolicy_::argument_package, mpl::int_<1> > argument_package;
  };

  template <class InnerSignature>
  struct outer_constructor_signature
  {
      typedef typename mpl::pop_front<InnerSignature>::type inner_args;
      typedef typename mpl::push_front<inner_args,object>::type outer_args;
      typedef typename mpl::push_front<outer_args,void>::type type;
  };


  template <>
  struct outer_constructor_signature<int>
  {
      typedef int type;
  };
# 150 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
  template <class F, class CallPolicies, class Sig>
  object make_constructor_aux(
      F f
    , CallPolicies const& p
    , Sig const&
  )
  {
      typedef typename outer_constructor_signature<Sig>::type outer_signature;

      typedef constructor_policy<CallPolicies> inner_policy;

      return objects::function_object(
          objects::py_function(
              detail::caller<F,inner_policy,Sig>(f, inner_policy(p))
            , outer_signature()
          )
      );
  }





  template <class F, class CallPolicies, class Sig, class NumKeywords>
  object make_constructor_aux(
      F f
      , CallPolicies const& p
      , Sig const&
      , detail::keyword_range const& kw
      , NumKeywords
      )
  {
      enum { arity = mpl::size<Sig>::value - 1 };

      typedef typename detail::error::more_keywords_than_function_arguments<
          NumKeywords::value, arity
          >::too_many_keywords assertion;

      typedef typename outer_constructor_signature<Sig>::type outer_signature;

      typedef constructor_policy<CallPolicies> inner_policy;

      return objects::function_object(
          objects::py_function(
              detail::caller<F,inner_policy,Sig>(f, inner_policy(p))
            , outer_signature()
          )
          , kw
      );
  }
# 209 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
  template <class F, class CallPolicies, class Keywords>
  object make_constructor_dispatch(F f, CallPolicies const& policies, Keywords const& kw, mpl::true_)
  {
      return detail::make_constructor_aux(
          f
        , policies
        , detail::get_signature(f)
        , kw.range()
        , mpl::int_<Keywords::size>()
      );
  }

  template <class F, class CallPolicies, class Signature>
  object make_constructor_dispatch(F f, CallPolicies const& policies, Signature const& sig, mpl::false_)
  {
      return detail::make_constructor_aux(
          f
        , policies
        , sig
      );
  }

}





template <class F>
object make_constructor(F f)
{
    return detail::make_constructor_aux(
        f,default_call_policies(), detail::get_signature(f));
}

template <class F, class CallPolicies>
object make_constructor(F f, CallPolicies const& policies)
{
    return detail::make_constructor_aux(
        f, policies, detail::get_signature(f));
}

template <class F, class CallPolicies, class KeywordsOrSignature>
object make_constructor(
    F f
  , CallPolicies const& policies
  , KeywordsOrSignature const& keywords_or_signature)
{
    typedef typename
        detail::is_reference_to_keywords<KeywordsOrSignature&>::type
        is_kw;

    return detail::make_constructor_dispatch(
        f
      , policies
      , keywords_or_signature
      , is_kw()
    );
}

template <class F, class CallPolicies, class Keywords, class Signature>
object make_constructor(
    F f
  , CallPolicies const& policies
  , Keywords const& kw
  , Signature const& sig
 )
{
    return detail::make_constructor_aux(
          f
        , policies
        , sig
        , kw.range()
        , mpl::int_<Keywords::size>()
      );
}


}}
# 42 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/manage_new_object.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/manage_new_object.hpp"
namespace boost { namespace python {

namespace detail
{
  template <class R>
  struct manage_new_object_requires_a_pointer_return_type

  {}

  ;
}

struct manage_new_object
{
    template <class T>
    struct apply
    {
        typedef typename mpl::if_c<
            boost::is_pointer<T>::value
            , to_python_indirect<T, detail::make_owning_holder>
            , detail::manage_new_object_requires_a_pointer_return_type<T>
        >::type type;
    };
};

}}
# 44 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/module.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/module.hpp"
# 1 "/usr/include/boost-1_42/boost/python/module_init.hpp" 1
# 12 "/usr/include/boost-1_42/boost/python/module_init.hpp"
namespace boost { namespace python { namespace detail {

 PyObject* init_module(char const* name, void(*)());

}}}
# 11 "/usr/include/boost-1_42/boost/python/module.hpp" 2
# 45 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/numeric.hpp" 1
# 18 "/usr/include/boost-1_42/boost/python/numeric.hpp"
namespace boost { namespace python { namespace numeric {

class array;

namespace aux
{
  struct array_base : object
  {



# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 37 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        array_base( object const& x0);


        array_base( object const& x0 , object const& x1);


        array_base( object const& x0 , object const& x1 , object const& x2);


        array_base( object const& x0 , object const& x1 , object const& x2 , object const& x3);


        array_base( object const& x0 , object const& x1 , object const& x2 , object const& x3 , object const& x4);


        array_base( object const& x0 , object const& x1 , object const& x2 , object const& x3 , object const& x4 , object const& x5);


        array_base( object const& x0 , object const& x1 , object const& x2 , object const& x3 , object const& x4 , object const& x5 , object const& x6);
# 30 "/usr/include/boost-1_42/boost/python/numeric.hpp" 2

      object argmax(long axis=-1);
      object argmin(long axis=-1);
      object argsort(long axis=-1);
      object astype(object const& type = object());
      void byteswap();
      object copy() const;
      object diagonal(long offset = 0, long axis1 = 0, long axis2 = 1) const;
      void info() const;
      bool is_c_array() const;
      bool isbyteswapped() const;
      array new_(object type) const;
      void sort();
      object trace(long offset = 0, long axis1 = 0, long axis2 = 1) const;
      object type() const;
      char typecode() const;

      object factory(
          object const& sequence = object()
        , object const& typecode = object()
        , bool copy = true
        , bool savespace = false
        , object type = object()
        , object shape = object());

      object getflat() const;
      long getrank() const;
      object getshape() const;
      bool isaligned() const;
      bool iscontiguous() const;
      long itemsize() const;
      long nelements() const;
      object nonzero() const;

      void put(object const& indices, object const& values);

      void ravel();

      object repeat(object const& repeats, long axis=0);

      void resize(object const& shape);

      void setflat(object const& flat);
      void setshape(object const& shape);

      void swapaxes(long axis1, long axis2);

      object take(object const& sequence, long axis = 0) const;

      void tofile(object const& file) const;

      str tostring() const;

      void transpose(object const& axes = object());

      object view() const;

   public:
      inline explicit array_base(python::detail::borrowed_reference p) : object(p) {} inline explicit array_base(python::detail::new_reference p) : object(p) {} inline explicit array_base(python::detail::new_non_null_reference p) : object(p) {};
  };

  struct array_object_manager_traits
  {
      static bool check(PyObject* obj);
      static detail::new_non_null_reference adopt(PyObject* obj);
      static PyTypeObject const* get_pytype() ;
  };
}

class array : public aux::array_base
{
    typedef aux::array_base base;
 public:

    object astype() { return base::astype(); }

    template <class Type>
    object astype(Type const& type_)
    {
        return base::astype(object(type_));
    }

    template <class Type>
    array new_(Type const& type_) const
    {
        return base::new_(object(type_));
    }

    template <class Sequence>
    void resize(Sequence const& x)
    {
        base::resize(object(x));
    }







# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 37 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        void resize( long x0) { resize(make_tuple( x0)); }


        void resize( long x0 , long x1) { resize(make_tuple( x0 , x1)); }


        void resize( long x0 , long x1 , long x2) { resize(make_tuple( x0 , x1 , x2)); }


        void resize( long x0 , long x1 , long x2 , long x3) { resize(make_tuple( x0 , x1 , x2 , x3)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4) { resize(make_tuple( x0 , x1 , x2 , x3 , x4)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12 , long x13) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12 , x13)); }


        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12 , long x13 , long x14) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12 , x13 , x14)); }
# 131 "/usr/include/boost-1_42/boost/python/numeric.hpp" 2

    template <class Sequence>
    void setshape(Sequence const& x)
    {
        base::setshape(object(x));
    }







# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 37 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        void setshape( long x0) { setshape(make_tuple( x0)); }


        void setshape( long x0 , long x1) { setshape(make_tuple( x0 , x1)); }


        void setshape( long x0 , long x1 , long x2) { setshape(make_tuple( x0 , x1 , x2)); }


        void setshape( long x0 , long x1 , long x2 , long x3) { setshape(make_tuple( x0 , x1 , x2 , x3)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12 , long x13) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12 , x13)); }


        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12 , long x13 , long x14) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12 , x13 , x14)); }
# 145 "/usr/include/boost-1_42/boost/python/numeric.hpp" 2

    template <class Indices, class Values>
    void put(Indices const& indices, Values const& values)
    {
        base::put(object(indices), object(values));
    }

    template <class Sequence>
    object take(Sequence const& sequence, long axis = 0)
    {
        return base::take(object(sequence), axis);
    }

    template <class File>
    void tofile(File const& f) const
    {
        base::tofile(object(f));
    }

    object factory()
    {
        return base::factory();
    }

    template <class Sequence>
    object factory(Sequence const& sequence)
    {
        return base::factory(object(sequence));
    }

    template <class Sequence, class Typecode>
    object factory(
        Sequence const& sequence
      , Typecode const& typecode_
      , bool copy = true
      , bool savespace = false
    )
    {
        return base::factory(object(sequence), object(typecode_), copy, savespace);
    }

    template <class Sequence, class Typecode, class Type>
    object factory(
        Sequence const& sequence
      , Typecode const& typecode_
      , bool copy
      , bool savespace
      , Type const& type
    )
    {
        return base::factory(object(sequence), object(typecode_), copy, savespace, object(type));
    }

    template <class Sequence, class Typecode, class Type, class Shape>
    object factory(
        Sequence const& sequence
      , Typecode const& typecode_
      , bool copy
      , bool savespace
      , Type const& type
      , Shape const& shape
    )
    {
        return base::factory(object(sequence), object(typecode_), copy, savespace, object(type), object(shape));
    }
# 218 "/usr/include/boost-1_42/boost/python/numeric.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 37 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        template < class T0> explicit array( T0 const& x0) : base( object(x0)) {}


        template < class T0 , class T1> explicit array( T0 const& x0 , T1 const& x1) : base( object(x0) , object(x1)) {}


        template < class T0 , class T1 , class T2> explicit array( T0 const& x0 , T1 const& x1 , T2 const& x2) : base( object(x0) , object(x1) , object(x2)) {}


        template < class T0 , class T1 , class T2 , class T3> explicit array( T0 const& x0 , T1 const& x1 , T2 const& x2 , T3 const& x3) : base( object(x0) , object(x1) , object(x2) , object(x3)) {}


        template < class T0 , class T1 , class T2 , class T3 , class T4> explicit array( T0 const& x0 , T1 const& x1 , T2 const& x2 , T3 const& x3 , T4 const& x4) : base( object(x0) , object(x1) , object(x2) , object(x3) , object(x4)) {}


        template < class T0 , class T1 , class T2 , class T3 , class T4 , class T5> explicit array( T0 const& x0 , T1 const& x1 , T2 const& x2 , T3 const& x3 , T4 const& x4 , T5 const& x5) : base( object(x0) , object(x1) , object(x2) , object(x3) , object(x4) , object(x5)) {}


        template < class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6> explicit array( T0 const& x0 , T1 const& x1 , T2 const& x2 , T3 const& x3 , T4 const& x4 , T5 const& x5 , T6 const& x6) : base( object(x0) , object(x1) , object(x2) , object(x3) , object(x4) , object(x5) , object(x6)) {}
# 219 "/usr/include/boost-1_42/boost/python/numeric.hpp" 2


    static void set_module_and_type(char const* package_name = 0, char const* type_attribute_name = 0);
    static std::string get_module_name();

 public:
    inline explicit array(python::detail::borrowed_reference p) : base(p) {} inline explicit array(python::detail::new_reference p) : base(p) {} inline explicit array(python::detail::new_non_null_reference p) : base(p) {};
};

}

namespace converter
{
  template <>
  struct object_manager_traits< numeric::array >
      : numeric::aux::array_object_manager_traits
  {
      static const bool is_specialized = true;
  };
}

}}
# 46 "/usr/include/boost-1_42/boost/python.hpp" 2



# 1 "/usr/include/boost-1_42/boost/python/opaque_pointer_converter.hpp" 1
# 15 "/usr/include/boost-1_42/boost/python/opaque_pointer_converter.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/dealloc.hpp" 1







namespace boost { namespace python { namespace detail {
    extern "C"
    {
        inline void dealloc(PyObject* self)
        {
          PyObject_Free(self);
        }
    }
}}}
# 16 "/usr/include/boost-1_42/boost/python/opaque_pointer_converter.hpp" 2
# 41 "/usr/include/boost-1_42/boost/python/opaque_pointer_converter.hpp"
namespace boost { namespace python {

template <class Pointee>
struct opaque
{
    opaque()
    {
        if (type_object.tp_name == 0)
        {
            type_object.tp_name = const_cast<char*>(type_id<Pointee*>().name());
            if (PyType_Ready (&type_object) < 0)
            {
                throw error_already_set();
            }

            this->register_self();
        }
    }

    static opaque instance;
private:

    static void* extract(PyObject* op)
    {
        return ((((PyObject*)(op))->ob_type) == (&type_object) || PyType_IsSubtype((((PyObject*)(op))->ob_type), (&type_object)))
            ? static_cast<python_instance*>(implicit_cast<void*>(op))->x
            : 0
            ;
    }

    static PyObject* wrap(void const* px)
    {
        Pointee* x = *static_cast<Pointee*const*>(px);

        if (x == 0)
            return detail::none();

        if ( python_instance *o = ( (python_instance *) _PyObject_New(&type_object) ) )
        {
            o->x = x;
            return static_cast<PyObject*>(implicit_cast<void*>(o));
        }
        else
        {
            throw error_already_set();
        }
    }

    void register_self()
    {
        converter::registration const *existing =
            converter::registry::query (type_id<Pointee*>());

        if ((existing == 0) || (existing->m_to_python == 0))
        {

            converter::registry::insert(&extract, type_id<Pointee>(), &get_pytype);
            converter::registry::insert(&wrap, type_id<Pointee*>(), &get_pytype);




        }
    }

    struct python_instance
    {
        Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
        Pointee* x;
    };

    static PyTypeObject type_object;

    static PyTypeObject const *get_pytype(){return &type_object; }

};

template <class Pointee>
opaque<Pointee> opaque<Pointee>::instance;

template <class Pointee>
PyTypeObject opaque<Pointee>::type_object =
{
    1, __null, 0,
    0,
    sizeof( typename opaque<Pointee>::python_instance ),
    0,
    ::boost::python::detail::dealloc,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,

    0

};
}}
# 50 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/operators.hpp" 1
# 17 "/usr/include/boost-1_42/boost/python/operators.hpp"
# 1 "/usr/include/boost-1_42/boost/python/self.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/self.hpp"
namespace boost { namespace python {







namespace self_ns
{



  struct self_t {};
  extern self_t self;

}

using self_ns::self_t;
using self_ns::self;

}}
# 18 "/usr/include/boost-1_42/boost/python/operators.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/other.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/other.hpp"
namespace boost { namespace python {

template<class T> struct other
{
    typedef T type;
};


namespace detail
{
  template<typename T>
  class is_other
  {
   public:
      static const bool value = false;
  };

  template<typename T>
  class is_other<other<T> >
  {
   public:
      static const bool value = true;
  };

  template<typename T>
  class unwrap_other
  {
   public:
      typedef T type;
  };

  template<typename T>
  class unwrap_other<other<T> >
  {
   public:
      typedef T type;
  };
}
# 112 "/usr/include/boost-1_42/boost/python/other.hpp"
}}
# 19 "/usr/include/boost-1_42/boost/python/operators.hpp" 2
# 1 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 1
# 17 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 2 3
# 18 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 19 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 2
# 28 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/is_signed.hpp" 1
# 19 "/usr/include/boost-1_42/boost/type_traits/is_signed.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 20 "/usr/include/boost-1_42/boost/type_traits/is_signed.hpp" 2

namespace boost {



namespace detail{



template <class T>
struct is_signed_values
{
   typedef typename remove_cv<T>::type no_cv_t;
   static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
   static const no_cv_t zero = (static_cast<no_cv_t>(0));
};

template <class T>
struct is_signed_helper
{
   typedef typename remove_cv<T>::type no_cv_t;
   static const bool value = (!(::boost::detail::is_signed_values<T>::minus_one > boost::detail::is_signed_values<T>::zero));
};

template <bool integral_type>
struct is_signed_select_helper
{
   template <class T>
   struct rebind
   {
      typedef is_signed_helper<T> type;
   };
};

template <>
struct is_signed_select_helper<false>
{
   template <class T>
   struct rebind
   {
      typedef false_type type;
   };
};

template <class T>
struct is_signed_imp
{
   typedef is_signed_select_helper<
      ::boost::type_traits::ice_or<
         ::boost::is_integral<T>::value,
         ::boost::is_enum<T>::value>::value
   > selector;
   typedef typename selector::template rebind<T> binder;
   typedef typename binder::type type;



   static const bool value = type::value;

};
# 121 "/usr/include/boost-1_42/boost/type_traits/is_signed.hpp"
}






template< typename T > struct is_signed : ::boost::integral_constant<bool,::boost::detail::is_signed_imp<T>::value> { };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 134 "/usr/include/boost-1_42/boost/type_traits/is_signed.hpp" 2
# 15 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_unsigned.hpp" 1
# 19 "/usr/include/boost-1_42/boost/type_traits/is_unsigned.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 20 "/usr/include/boost-1_42/boost/type_traits/is_unsigned.hpp" 2

namespace boost {



namespace detail{



template <class T>
struct is_unsigned_values
{
   typedef typename remove_cv<T>::type no_cv_t;
   static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
   static const no_cv_t zero = (static_cast<no_cv_t>(0));
};

template <class T>
struct is_ununsigned_helper
{
   static const bool value = (::boost::detail::is_unsigned_values<T>::minus_one > ::boost::detail::is_unsigned_values<T>::zero);
};

template <bool integral_type>
struct is_ununsigned_select_helper
{
   template <class T>
   struct rebind
   {
      typedef is_ununsigned_helper<T> type;
   };
};

template <>
struct is_ununsigned_select_helper<false>
{
   template <class T>
   struct rebind
   {
      typedef false_type type;
   };
};

template <class T>
struct is_unsigned_imp
{
   typedef is_ununsigned_select_helper<
      ::boost::type_traits::ice_or<
         ::boost::is_integral<T>::value,
         ::boost::is_enum<T>::value>::value
   > selector;
   typedef typename selector::template rebind<T> binder;
   typedef typename binder::type type;
   static const bool value = type::value;
};
# 116 "/usr/include/boost-1_42/boost/type_traits/is_unsigned.hpp"
}






template< typename T > struct is_unsigned : ::boost::integral_constant<bool,::boost::detail::is_unsigned_imp<T>::value> { };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 129 "/usr/include/boost-1_42/boost/type_traits/is_unsigned.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp" 2
# 29 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 30 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp" 2

namespace boost {

namespace detail {

template <class T>
struct make_unsigned_imp
{
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)>
 boost_static_assert_typedef_39;

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)>

 boost_static_assert_typedef_43;


   typedef typename remove_cv<T>::type t_no_cv;
   typedef typename mpl::if_c<
      (::boost::type_traits::ice_and<
         ::boost::is_unsigned<T>::value,
         ::boost::is_integral<T>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
      T,
      typename mpl::if_c<
         (::boost::type_traits::ice_and<
            ::boost::is_integral<T>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
         ::value),
         typename mpl::if_<
            is_same<t_no_cv, signed char>,
            unsigned char,
            typename mpl::if_<
               is_same<t_no_cv, short>,
               unsigned short,
               typename mpl::if_<
                  is_same<t_no_cv, int>,
                  unsigned int,
                  typename mpl::if_<
                     is_same<t_no_cv, long>,
                     unsigned long,

                     boost::ulong_long_type





                  >::type
               >::type
            >::type
         >::type,

         typename mpl::if_c<
            sizeof(t_no_cv) == sizeof(unsigned char),
            unsigned char,
            typename mpl::if_c<
               sizeof(t_no_cv) == sizeof(unsigned short),
               unsigned short,
               typename mpl::if_c<
                  sizeof(t_no_cv) == sizeof(unsigned int),
                  unsigned int,
                  typename mpl::if_c<
                     sizeof(t_no_cv) == sizeof(unsigned long),
                     unsigned long,

                     boost::ulong_long_type





                  >::type
               >::type
            >::type
         >::type
      >::type
   >::type base_integer_type;


   typedef typename mpl::if_<
      is_const<T>,
      typename add_const<base_integer_type>::type,
      base_integer_type
   >::type const_base_integer_type;


   typedef typename mpl::if_<
      is_volatile<T>,
      typename add_volatile<const_base_integer_type>::type,
      const_base_integer_type
   >::type type;
};


}

template< typename T > struct make_unsigned { typedef typename boost::detail::make_unsigned_imp<T>::type type; };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 135 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp" 2
# 29 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 2


# 1 "/usr/include/boost-1_42/boost/detail/lcast_precision.hpp" 1
# 11 "/usr/include/boost-1_42/boost/detail/lcast_precision.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 2 3
# 12 "/usr/include/boost-1_42/boost/detail/lcast_precision.hpp" 2
# 36 "/usr/include/boost-1_42/boost/detail/lcast_precision.hpp"
namespace boost { namespace detail {

class lcast_abstract_stub {};





template<class T>
struct lcast_precision
{



    typedef typename boost::mpl::if_<
        boost::is_abstract<T>
      , std::numeric_limits<lcast_abstract_stub>
      , std::numeric_limits<T>
      >::type limits;


    static const bool use_default_precision = !limits::is_specialized || limits::is_exact

         ;

    static const bool is_specialized_bin = !use_default_precision && limits::radix == 2 && limits::digits > 0


         ;

    static const bool is_specialized_dec = !use_default_precision && limits::radix == 10 && limits::digits10 > 0


         ;

    static const std::streamsize streamsize_max = boost::integer_traits<std::streamsize>::const_max

         ;

    static const unsigned int precision_dec = limits::digits10 + 1U;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!is_specialized_dec || precision_dec <= streamsize_max + 0UL) == 0 ? false : true) >)>

 boost_static_assert_typedef_79;

    static const unsigned long precision_bin = 2UL + limits::digits * 30103UL / 100000UL

         ;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!is_specialized_bin || (limits::digits + 0UL < (9223372036854775807L * 2UL + 1UL) / 30103UL && precision_bin > limits::digits10 + 0UL && precision_bin <= streamsize_max + 0UL)) == 0 ? false : true) >)>



 boost_static_assert_typedef_89;

    static const std::streamsize value = is_specialized_bin ? precision_bin : is_specialized_dec ? precision_dec : 6


         ;
};


template<class T>
inline std::streamsize lcast_get_precision(T* = 0)
{

    return lcast_precision<T>::value;
# 165 "/usr/include/boost-1_42/boost/detail/lcast_precision.hpp"
}

template<class T>
inline void lcast_set_precision(std::ios_base& stream, T*)
{
    stream.precision(lcast_get_precision<T>());
}

template<class Source, class Target>
inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
{
    std::streamsize const s = lcast_get_precision((Source*)0);
    std::streamsize const t = lcast_get_precision((Target*)0);
    stream.precision(s > t ? s : t);
}

}}
# 32 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 2



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/locale" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/locale" 3
       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/locale" 3




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ctime" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ctime" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ctime" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ctime" 2 3
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ctime" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  using ::clock_t;
  using ::time_t;
  using ::tm;

  using ::clock;
  using ::difftime;
  using ::mktime;
  using ::time;
  using ::asctime;
  using ::ctime;
  using ::gmtime;
  using ::localtime;
  using ::strftime;

}
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
  class time_base
  {
  public:
    enum dateorder { no_order, dmy, mdy, ymd, ydm };
  };

  template<typename _CharT>
    struct __timepunct_cache : public locale::facet
    {

      static const _CharT* _S_timezones[14];

      const _CharT* _M_date_format;
      const _CharT* _M_date_era_format;
      const _CharT* _M_time_format;
      const _CharT* _M_time_era_format;
      const _CharT* _M_date_time_format;
      const _CharT* _M_date_time_era_format;
      const _CharT* _M_am;
      const _CharT* _M_pm;
      const _CharT* _M_am_pm_format;


      const _CharT* _M_day1;
      const _CharT* _M_day2;
      const _CharT* _M_day3;
      const _CharT* _M_day4;
      const _CharT* _M_day5;
      const _CharT* _M_day6;
      const _CharT* _M_day7;


      const _CharT* _M_aday1;
      const _CharT* _M_aday2;
      const _CharT* _M_aday3;
      const _CharT* _M_aday4;
      const _CharT* _M_aday5;
      const _CharT* _M_aday6;
      const _CharT* _M_aday7;


      const _CharT* _M_month01;
      const _CharT* _M_month02;
      const _CharT* _M_month03;
      const _CharT* _M_month04;
      const _CharT* _M_month05;
      const _CharT* _M_month06;
      const _CharT* _M_month07;
      const _CharT* _M_month08;
      const _CharT* _M_month09;
      const _CharT* _M_month10;
      const _CharT* _M_month11;
      const _CharT* _M_month12;


      const _CharT* _M_amonth01;
      const _CharT* _M_amonth02;
      const _CharT* _M_amonth03;
      const _CharT* _M_amonth04;
      const _CharT* _M_amonth05;
      const _CharT* _M_amonth06;
      const _CharT* _M_amonth07;
      const _CharT* _M_amonth08;
      const _CharT* _M_amonth09;
      const _CharT* _M_amonth10;
      const _CharT* _M_amonth11;
      const _CharT* _M_amonth12;

      bool _M_allocated;

      __timepunct_cache(size_t __refs = 0) : facet(__refs),
      _M_date_format(__null), _M_date_era_format(__null), _M_time_format(__null),
      _M_time_era_format(__null), _M_date_time_format(__null),
      _M_date_time_era_format(__null), _M_am(__null), _M_pm(__null),
      _M_am_pm_format(__null), _M_day1(__null), _M_day2(__null), _M_day3(__null),
      _M_day4(__null), _M_day5(__null), _M_day6(__null), _M_day7(__null),
      _M_aday1(__null), _M_aday2(__null), _M_aday3(__null), _M_aday4(__null),
      _M_aday5(__null), _M_aday6(__null), _M_aday7(__null), _M_month01(__null),
      _M_month02(__null), _M_month03(__null), _M_month04(__null), _M_month05(__null),
      _M_month06(__null), _M_month07(__null), _M_month08(__null), _M_month09(__null),
      _M_month10(__null), _M_month11(__null), _M_month12(__null), _M_amonth01(__null),
      _M_amonth02(__null), _M_amonth03(__null), _M_amonth04(__null),
      _M_amonth05(__null), _M_amonth06(__null), _M_amonth07(__null),
      _M_amonth08(__null), _M_amonth09(__null), _M_amonth10(__null),
      _M_amonth11(__null), _M_amonth12(__null), _M_allocated(false)
      { }

      ~__timepunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __timepunct_cache&
      operator=(const __timepunct_cache&);

      explicit
      __timepunct_cache(const __timepunct_cache&);
    };

  template<typename _CharT>
    __timepunct_cache<_CharT>::~__timepunct_cache()
    {
      if (_M_allocated)
 {

 }
    }


  template<>
    const char*
    __timepunct_cache<char>::_S_timezones[14];


  template<>
    const wchar_t*
    __timepunct_cache<wchar_t>::_S_timezones[14];



  template<typename _CharT>
    const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];

  template<typename _CharT>
    class __timepunct : public locale::facet
    {
    public:

      typedef _CharT __char_type;
      typedef basic_string<_CharT> __string_type;
      typedef __timepunct_cache<_CharT> __cache_type;

    protected:
      __cache_type* _M_data;
      __c_locale _M_c_locale_timepunct;
      const char* _M_name_timepunct;

    public:

      static locale::id id;

      explicit
      __timepunct(size_t __refs = 0);

      explicit
      __timepunct(__cache_type* __cache, size_t __refs = 0);
# 208 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);



      void
      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
      const tm* __tm) const throw ();

      void
      _M_date_formats(const _CharT** __date) const
      {

 __date[0] = _M_data->_M_date_format;
 __date[1] = _M_data->_M_date_era_format;
      }

      void
      _M_time_formats(const _CharT** __time) const
      {

 __time[0] = _M_data->_M_time_format;
 __time[1] = _M_data->_M_time_era_format;
      }

      void
      _M_date_time_formats(const _CharT** __dt) const
      {

 __dt[0] = _M_data->_M_date_time_format;
 __dt[1] = _M_data->_M_date_time_era_format;
      }

      void
      _M_am_pm_format(const _CharT* __ampm) const
      { __ampm = _M_data->_M_am_pm_format; }

      void
      _M_am_pm(const _CharT** __ampm) const
      {
 __ampm[0] = _M_data->_M_am;
 __ampm[1] = _M_data->_M_pm;
      }

      void
      _M_days(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_day1;
 __days[1] = _M_data->_M_day2;
 __days[2] = _M_data->_M_day3;
 __days[3] = _M_data->_M_day4;
 __days[4] = _M_data->_M_day5;
 __days[5] = _M_data->_M_day6;
 __days[6] = _M_data->_M_day7;
      }

      void
      _M_days_abbreviated(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_aday1;
 __days[1] = _M_data->_M_aday2;
 __days[2] = _M_data->_M_aday3;
 __days[3] = _M_data->_M_aday4;
 __days[4] = _M_data->_M_aday5;
 __days[5] = _M_data->_M_aday6;
 __days[6] = _M_data->_M_aday7;
      }

      void
      _M_months(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_month01;
 __months[1] = _M_data->_M_month02;
 __months[2] = _M_data->_M_month03;
 __months[3] = _M_data->_M_month04;
 __months[4] = _M_data->_M_month05;
 __months[5] = _M_data->_M_month06;
 __months[6] = _M_data->_M_month07;
 __months[7] = _M_data->_M_month08;
 __months[8] = _M_data->_M_month09;
 __months[9] = _M_data->_M_month10;
 __months[10] = _M_data->_M_month11;
 __months[11] = _M_data->_M_month12;
      }

      void
      _M_months_abbreviated(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_amonth01;
 __months[1] = _M_data->_M_amonth02;
 __months[2] = _M_data->_M_amonth03;
 __months[3] = _M_data->_M_amonth04;
 __months[4] = _M_data->_M_amonth05;
 __months[5] = _M_data->_M_amonth06;
 __months[6] = _M_data->_M_amonth07;
 __months[7] = _M_data->_M_amonth08;
 __months[8] = _M_data->_M_amonth09;
 __months[9] = _M_data->_M_amonth10;
 __months[10] = _M_data->_M_amonth11;
 __months[11] = _M_data->_M_amonth12;
      }

    protected:
      virtual
      ~__timepunct();


      void
      _M_initialize_timepunct(__c_locale __cloc = __null);
    };

  template<typename _CharT>
    locale::id __timepunct<_CharT>::id;


  template<>
    void
    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();


  template<>
    void
    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
     const tm*) const throw ();


}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/time_members.h" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/time_members.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(size_t __refs)
    : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
      _M_name_timepunct(_S_get_c_name())
    { _M_initialize_timepunct(); }

  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
    : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(__null),
      _M_name_timepunct(_S_get_c_name())
    { _M_initialize_timepunct(); }

  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
         size_t __refs)
    : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
      _M_name_timepunct(__null)
    {
      if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
 {
   const size_t __len = __builtin_strlen(__s) + 1;
   char* __tmp = new char[__len];
   __builtin_memcpy(__tmp, __s, __len);
   _M_name_timepunct = __tmp;
 }
      else
 _M_name_timepunct = _S_get_c_name();

      try
 { _M_initialize_timepunct(__cloc); }
      catch(...)
 {
   if (_M_name_timepunct != _S_get_c_name())
     delete [] _M_name_timepunct;
   throw;
 }
    }

  template<typename _CharT>
    __timepunct<_CharT>::~__timepunct()
    {
      if (_M_name_timepunct != _S_get_c_name())
 delete [] _M_name_timepunct;
      delete _M_data;
      _S_destroy_c_locale(_M_c_locale_timepunct);
    }

}
# 346 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 362 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _InIter>
    class time_get : public locale::facet, public time_base
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;

      typedef basic_string<_CharT> __string_type;


      static locale::id id;
# 384 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      time_get(size_t __refs = 0)
      : facet (__refs) { }
# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      dateorder
      date_order() const
      { return this->do_date_order(); }
# 425 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get_time(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get_date(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
# 478 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
# 507 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
# 533 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get_year(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_year(__beg, __end, __io, __err, __tm); }

    protected:

      virtual
      ~time_get() { }
# 553 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual dateorder
      do_date_order() const;
# 571 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 590 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 609 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
       ios_base::iostate& __err, tm* __tm) const;
# 628 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
         ios_base::iostate& __err, tm* __tm) const;
# 647 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;


      iter_type
      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
       int __min, int __max, size_t __len,
       ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
        const _CharT** __names, size_t __indexlen,
        ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
          const _CharT** __names, size_t __indexlen,
          ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
       ios_base::iostate& __err, tm* __tm,
       const _CharT* __format) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id time_get<_CharT, _InIter>::id;


  template<typename _CharT, typename _InIter>
    class time_get_byname : public time_get<_CharT, _InIter>
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;

      explicit
      time_get_byname(const char*, size_t __refs = 0)
      : time_get<_CharT, _InIter>(__refs) { }

    protected:
      virtual
      ~time_get_byname() { }
    };
# 709 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _OutIter>
    class time_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 730 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      time_put(size_t __refs = 0)
      : facet(__refs) { }
# 749 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
   const _CharT* __beg, const _CharT* __end) const;
# 769 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   const tm* __tm, char __format, char __mod = 0) const
      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }

    protected:

      virtual
      ~time_put()
      { }
# 796 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
      char __format, char __mod) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id time_put<_CharT, _OutIter>::id;


  template<typename _CharT, typename _OutIter>
    class time_put_byname : public time_put<_CharT, _OutIter>
    {
    public:

      typedef _CharT char_type;
      typedef _OutIter iter_type;

      explicit
      time_put_byname(const char*, size_t __refs = 0)
      : time_put<_CharT, _OutIter>(__refs)
      { };

    protected:
      virtual
      ~time_put_byname() { }
    };
# 835 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
  class money_base
  {
  public:
    enum part { none, space, symbol, sign, value };
    struct pattern { char field[4]; };

    static const pattern _S_default_pattern;

    enum
    {
      _S_minus,
      _S_zero,
      _S_end = 11
    };



    static const char* _S_atoms;



    __attribute__ ((__const__)) static pattern
    _S_construct_pattern(char __precedes, char __space, char __posn) throw ();
  };

  template<typename _CharT, bool _Intl>
    struct __moneypunct_cache : public locale::facet
    {
      const char* _M_grouping;
      size_t _M_grouping_size;
      bool _M_use_grouping;
      _CharT _M_decimal_point;
      _CharT _M_thousands_sep;
      const _CharT* _M_curr_symbol;
      size_t _M_curr_symbol_size;
      const _CharT* _M_positive_sign;
      size_t _M_positive_sign_size;
      const _CharT* _M_negative_sign;
      size_t _M_negative_sign_size;
      int _M_frac_digits;
      money_base::pattern _M_pos_format;
      money_base::pattern _M_neg_format;




      _CharT _M_atoms[money_base::_S_end];

      bool _M_allocated;

      __moneypunct_cache(size_t __refs = 0) : facet(__refs),
      _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
      _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
      _M_curr_symbol(__null), _M_curr_symbol_size(0),
      _M_positive_sign(__null), _M_positive_sign_size(0),
      _M_negative_sign(__null), _M_negative_sign_size(0),
      _M_frac_digits(0),
      _M_pos_format(money_base::pattern()),
      _M_neg_format(money_base::pattern()), _M_allocated(false)
      { }

      ~__moneypunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __moneypunct_cache&
      operator=(const __moneypunct_cache&);

      explicit
      __moneypunct_cache(const __moneypunct_cache&);
    };

  template<typename _CharT, bool _Intl>
    __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
    {
      if (_M_allocated)
 {
   delete [] _M_grouping;
   delete [] _M_curr_symbol;
   delete [] _M_positive_sign;
   delete [] _M_negative_sign;
 }
    }
# 928 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT, bool _Intl>
    class moneypunct : public locale::facet, public money_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

    private:
      __cache_type* _M_data;

    public:


      static const bool intl = _Intl;

      static locale::id id;
# 957 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
      { _M_initialize_moneypunct(); }
# 969 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_moneypunct(); }
# 984 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
      : facet(__refs), _M_data(__null)
      { _M_initialize_moneypunct(__cloc, __s); }
# 998 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1011 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1041 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1054 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      string_type
      curr_symbol() const
      { return this->do_curr_symbol(); }
# 1071 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      string_type
      positive_sign() const
      { return this->do_positive_sign(); }
# 1088 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      string_type
      negative_sign() const
      { return this->do_negative_sign(); }
# 1104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      int
      frac_digits() const
      { return this->do_frac_digits(); }
# 1140 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      pattern
      pos_format() const
      { return this->do_pos_format(); }

      pattern
      neg_format() const
      { return this->do_neg_format(); }


    protected:

      virtual
      ~moneypunct();
# 1162 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1174 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1187 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1200 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_curr_symbol() const
      { return _M_data->_M_curr_symbol; }
# 1213 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_positive_sign() const
      { return _M_data->_M_positive_sign; }
# 1226 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_negative_sign() const
      { return _M_data->_M_negative_sign; }
# 1240 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual int
      do_frac_digits() const
      { return _M_data->_M_frac_digits; }
# 1254 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual pattern
      do_pos_format() const
      { return _M_data->_M_pos_format; }
# 1268 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual pattern
      do_neg_format() const
      { return _M_data->_M_neg_format; }


       void
       _M_initialize_moneypunct(__c_locale __cloc = __null,
    const char* __name = __null);
    };

  template<typename _CharT, bool _Intl>
    locale::id moneypunct<_CharT, _Intl>::id;

  template<typename _CharT, bool _Intl>
    const bool moneypunct<_CharT, _Intl>::intl;

  template<>
    moneypunct<char, true>::~moneypunct();

  template<>
    moneypunct<char, false>::~moneypunct();

  template<>
    void
    moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);

  template<>
    void
    moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);


  template<>
    moneypunct<wchar_t, true>::~moneypunct();

  template<>
    moneypunct<wchar_t, false>::~moneypunct();

  template<>
    void
    moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
       const char*);

  template<>
    void
    moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
        const char*);



  template<typename _CharT, bool _Intl>
    class moneypunct_byname : public moneypunct<_CharT, _Intl>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static const bool intl = _Intl;

      explicit
      moneypunct_byname(const char* __s, size_t __refs = 0)
      : moneypunct<_CharT, _Intl>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_moneypunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }

    protected:
      virtual
      ~moneypunct_byname() { }
    };

  template<typename _CharT, bool _Intl>
    const bool moneypunct_byname<_CharT, _Intl>::intl;


# 1363 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _InIter>
    class money_get : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;
      typedef basic_string<_CharT> string_type;



      static locale::id id;
# 1385 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      money_get(size_t __refs = 0) : facet(__refs) { }
# 1415 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, long double& __units) const
      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
# 1446 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, string_type& __digits) const
      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }

    protected:

      virtual
      ~money_get() { }
# 1469 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, long double& __units) const;
# 1481 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, string_type& __digits) const;
# 1492 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      template<bool _Intl>
        iter_type
        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, string& __digits) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id money_get<_CharT, _InIter>::id;
# 1514 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _OutIter>
    class money_put : public locale::facet
    {
    public:


      typedef _CharT char_type;
      typedef _OutIter iter_type;
      typedef basic_string<_CharT> string_type;



      static locale::id id;
# 1535 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      money_put(size_t __refs = 0) : facet(__refs) { }
# 1555 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, long double __units) const
      { return this->do_put(__s, __intl, __io, __fill, __units); }
# 1578 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, const string_type& __digits) const
      { return this->do_put(__s, __intl, __io, __fill, __digits); }

    protected:

      virtual
      ~money_put() { }
# 1612 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      long double __units) const;
# 1636 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      const string_type& __digits) const;
# 1647 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      template<bool _Intl>
        iter_type
        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
    const string_type& __digits) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id money_put<_CharT, _OutIter>::id;







  struct messages_base
  {
    typedef int catalog;
  };
# 1688 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT>
    class messages : public locale::facet, public messages_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


    protected:


      __c_locale _M_c_locale_messages;
      const char* _M_name_messages;

    public:

      static locale::id id;
# 1716 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      messages(size_t __refs = 0);
# 1730 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
# 1743 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return this->do_open(__s, __loc); }
# 1761 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>&, const locale&, const char*) const;
# 1779 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      string_type
      get(catalog __c, int __set, int __msgid, const string_type& __s) const
      { return this->do_get(__c, __set, __msgid, __s); }
# 1790 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      void
      close(catalog __c) const
      { return this->do_close(__c); }

    protected:

      virtual
      ~messages();
# 1810 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual catalog
      do_open(const basic_string<char>&, const locale&) const;
# 1829 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_get(catalog, int, int, const string_type& __dfault) const;






      virtual void
      do_close(catalog) const;


      char*
      _M_convert_to_char(const string_type& __msg) const
      {

 return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
      }


      string_type
      _M_convert_from_char(char*) const
      {
# 1886 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
 return string_type();
      }
     };

  template<typename _CharT>
    locale::id messages<_CharT>::id;


  template<>
    string
    messages<char>::do_get(catalog, int, int, const string&) const;


  template<>
    wstring
    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;



   template<typename _CharT>
    class messages_byname : public messages<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      messages_byname(const char* __s, size_t __refs = 0);

    protected:
      virtual
      ~messages_byname()
      { }
    };

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/messages_members.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/messages_members.h" 3
# 1 "/usr/include/libintl.h" 1 3 4
# 35 "/usr/include/libintl.h" 3 4
extern "C" {




extern char *gettext (__const char *__msgid)
     throw () __attribute__ ((__format_arg__ (1)));



extern char *dgettext (__const char *__domainname, __const char *__msgid)
     throw () __attribute__ ((__format_arg__ (2)));
extern char *__dgettext (__const char *__domainname, __const char *__msgid)
     throw () __attribute__ ((__format_arg__ (2)));



extern char *dcgettext (__const char *__domainname,
   __const char *__msgid, int __category)
     throw () __attribute__ ((__format_arg__ (2)));
extern char *__dcgettext (__const char *__domainname,
     __const char *__msgid, int __category)
     throw () __attribute__ ((__format_arg__ (2)));




extern char *ngettext (__const char *__msgid1, __const char *__msgid2,
         unsigned long int __n)
     throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));



extern char *dngettext (__const char *__domainname, __const char *__msgid1,
   __const char *__msgid2, unsigned long int __n)
     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));



extern char *dcngettext (__const char *__domainname, __const char *__msgid1,
    __const char *__msgid2, unsigned long int __n,
    int __category)
     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));





extern char *textdomain (__const char *__domainname) throw ();



extern char *bindtextdomain (__const char *__domainname,
        __const char *__dirname) throw ();



extern char *bind_textdomain_codeset (__const char *__domainname,
          __const char *__codeset) throw ();
# 122 "/usr/include/libintl.h" 3 4
}
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/messages_members.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {


  template<typename _CharT>
     messages<_CharT>::messages(size_t __refs)
     : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
       _M_name_messages(_S_get_c_name())
     { }

  template<typename _CharT>
     messages<_CharT>::messages(__c_locale __cloc, const char* __s,
    size_t __refs)
     : facet(__refs), _M_c_locale_messages(__null), _M_name_messages(__null)
     {
       if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
  {
    const size_t __len = __builtin_strlen(__s) + 1;
    char* __tmp = new char[__len];
    __builtin_memcpy(__tmp, __s, __len);
    _M_name_messages = __tmp;
  }
       else
  _M_name_messages = _S_get_c_name();


       _M_c_locale_messages = _S_clone_c_locale(__cloc);
     }

  template<typename _CharT>
    typename messages<_CharT>::catalog
    messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
      const char* __dir) const
    {
      bindtextdomain(__s.c_str(), __dir);
      return this->do_open(__s, __loc);
    }


  template<typename _CharT>
    messages<_CharT>::~messages()
    {
      if (_M_name_messages != _S_get_c_name())
 delete [] _M_name_messages;
      _S_destroy_c_locale(_M_c_locale_messages);
    }

  template<typename _CharT>
    typename messages<_CharT>::catalog
    messages<_CharT>::do_open(const basic_string<char>& __s,
         const locale&) const
    {


      textdomain(__s.c_str());
      return 0;
    }

  template<typename _CharT>
    void
    messages<_CharT>::do_close(catalog) const
    { }


   template<typename _CharT>
     messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
     : messages<_CharT>(__refs)
     {
       if (this->_M_name_messages != locale::facet::_S_get_c_name())
  {
    delete [] this->_M_name_messages;
    if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0)
      {
        const size_t __len = __builtin_strlen(__s) + 1;
        char* __tmp = new char[__len];
        __builtin_memcpy(__tmp, __s, __len);
        this->_M_name_messages = __tmp;
      }
    else
      this->_M_name_messages = locale::facet::_S_get_c_name();
  }

       if (__builtin_strcmp(__s, "C") != 0
    && __builtin_strcmp(__s, "POSIX") != 0)
  {
    this->_S_destroy_c_locale(this->_M_c_locale_messages);
    this->_S_create_c_locale(this->_M_c_locale_messages, __s);
  }
     }

}
# 1925 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 1 3
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
       
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3

namespace std __attribute__ ((__visibility__ ("default"))) {


  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };
# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
  template<typename _InternT, typename _ExternT, typename _StateT>
    class __codecvt_abstract_base
    : public locale::facet, public codecvt_base
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;
# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
      result
      out(state_type& __state, const intern_type* __from,
   const intern_type* __from_end, const intern_type*& __from_next,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const
      {
 return this->do_out(__state, __from, __from_end, __from_next,
       __to, __to_end, __to_next);
      }
# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
      result
      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
       extern_type*& __to_next) const
      { return this->do_unshift(__state, __to,__to_end,__to_next); }
# 194 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
      result
      in(state_type& __state, const extern_type* __from,
  const extern_type* __from_end, const extern_type*& __from_next,
  intern_type* __to, intern_type* __to_end,
  intern_type*& __to_next) const
      {
 return this->do_in(__state, __from, __from_end, __from_next,
      __to, __to_end, __to_next);
      }

      int
      encoding() const throw()
      { return this->do_encoding(); }

      bool
      always_noconv() const throw()
      { return this->do_always_noconv(); }

      int
      length(state_type& __state, const extern_type* __from,
      const extern_type* __end, size_t __max) const
      { return this->do_length(__state, __from, __end, __max); }

      int
      max_length() const throw()
      { return this->do_max_length(); }

    protected:
      explicit
      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }

      virtual
      ~__codecvt_abstract_base() { }
# 235 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const = 0;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const = 0;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const = 0;

      virtual int
      do_encoding() const throw() = 0;

      virtual bool
      do_always_noconv() const throw() = 0;

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const = 0;

      virtual int
      do_max_length() const throw() = 0;
    };
# 274 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
   template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt
    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs) { }

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt() { }

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };

  template<typename _InternT, typename _ExternT, typename _StateT>
    locale::id codecvt<_InternT, _ExternT, _StateT>::id;


  template<>
    class codecvt<char, char, mbstate_t>
    : public __codecvt_abstract_base<char, char, mbstate_t>
    {
    public:

      typedef char intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
  };



  template<>
    class codecvt<wchar_t, char, mbstate_t>
    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
    {
    public:

      typedef wchar_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };



  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
    {
    public:
      explicit
      codecvt_byname(const char* __s, size_t __refs = 0)
      : codecvt<_InternT, _ExternT, _StateT>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
     this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
   }
      }

    protected:
      virtual
      ~codecvt_byname() { }
    };





  extern template class codecvt_byname<char, char, mbstate_t>;

  extern template
    const codecvt<char, char, mbstate_t>&
    use_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<char, char, mbstate_t> >(const locale&);


  extern template class codecvt_byname<wchar_t, char, mbstate_t>;

  extern template
    const codecvt<wchar_t, char, mbstate_t>&
    use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);



}
# 1928 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 3
       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 3

namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _CharT, bool _Intl>
    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
    {
      const __moneypunct_cache<_CharT, _Intl>*
      operator() (const locale& __loc) const
      {
 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __moneypunct_cache<_CharT, _Intl>* __tmp = __null;
     try
       {
  __tmp = new __moneypunct_cache<_CharT, _Intl>;
  __tmp->_M_cache(__loc);
       }
     catch(...)
       {
  delete __tmp;
  throw;
       }
     __loc._M_impl->_M_install_cache(__tmp, __i);
   }
 return static_cast<
   const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
      }
    };

  template<typename _CharT, bool _Intl>
    void
    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
    {
      _M_allocated = true;

      const moneypunct<_CharT, _Intl>& __mp =
 use_facet<moneypunct<_CharT, _Intl> >(__loc);

      _M_decimal_point = __mp.decimal_point();
      _M_thousands_sep = __mp.thousands_sep();
      _M_frac_digits = __mp.frac_digits();

      char* __grouping = 0;
      _CharT* __curr_symbol = 0;
      _CharT* __positive_sign = 0;
      _CharT* __negative_sign = 0;
      try
 {
   _M_grouping_size = __mp.grouping().size();
   __grouping = new char[_M_grouping_size];
   __mp.grouping().copy(__grouping, _M_grouping_size);
   _M_grouping = __grouping;
   _M_use_grouping = (_M_grouping_size
        && static_cast<signed char>(_M_grouping[0]) > 0
        && (_M_grouping[0]
     != __gnu_cxx::__numeric_traits<char>::__max));

   _M_curr_symbol_size = __mp.curr_symbol().size();
   __curr_symbol = new _CharT[_M_curr_symbol_size];
   __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
   _M_curr_symbol = __curr_symbol;

   _M_positive_sign_size = __mp.positive_sign().size();
   __positive_sign = new _CharT[_M_positive_sign_size];
   __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
   _M_positive_sign = __positive_sign;

   _M_negative_sign_size = __mp.negative_sign().size();
   __negative_sign = new _CharT[_M_negative_sign_size];
   __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
   _M_negative_sign = __negative_sign;

   _M_pos_format = __mp.pos_format();
   _M_neg_format = __mp.neg_format();

   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
   __ct.widen(money_base::_S_atoms,
       money_base::_S_atoms + money_base::_S_end, _M_atoms);
 }
      catch(...)
 {
   delete [] __grouping;
   delete [] __curr_symbol;
   delete [] __positive_sign;
   delete [] __negative_sign;
   throw;
 }
    }



  template<typename _CharT, typename _InIter>
    template<bool _Intl>
      _InIter
      money_get<_CharT, _InIter>::
      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, string& __units) const
      {
 typedef char_traits<_CharT> __traits_type;
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;


 bool __negative = false;

 size_type __sign_size = 0;

 const bool __mandatory_sign = (__lc->_M_positive_sign_size
           && __lc->_M_negative_sign_size);

 string __grouping_tmp;
 if (__lc->_M_use_grouping)
   __grouping_tmp.reserve(32);

 int __last_pos = 0;

 int __n = 0;

 bool __testvalid = true;

 bool __testdecfound = false;


 string __res;
 __res.reserve(32);

 const char_type* __lit_zero = __lit + money_base::_S_zero;
 const money_base::pattern __p = __lc->_M_neg_format;
 for (int __i = 0; __i < 4 && __testvalid; ++__i)
   {
     const part __which = static_cast<part>(__p.field[__i]);
     switch (__which)
       {
       case money_base::symbol:




  if (__io.flags() & ios_base::showbase || __sign_size > 1
      || __i == 0
      || (__i == 1 && (__mandatory_sign
         || (static_cast<part>(__p.field[0])
      == money_base::sign)
         || (static_cast<part>(__p.field[2])
      == money_base::space)))
      || (__i == 2 && ((static_cast<part>(__p.field[3])
          == money_base::value)
         || (__mandatory_sign
      && (static_cast<part>(__p.field[3])
          == money_base::sign)))))
    {
      const size_type __len = __lc->_M_curr_symbol_size;
      size_type __j = 0;
      for (; __beg != __end && __j < __len
      && *__beg == __lc->_M_curr_symbol[__j];
    ++__beg, ++__j);
      if (__j != __len
   && (__j || __io.flags() & ios_base::showbase))
        __testvalid = false;
    }
  break;
       case money_base::sign:

  if (__lc->_M_positive_sign_size && __beg != __end
      && *__beg == __lc->_M_positive_sign[0])
    {
      __sign_size = __lc->_M_positive_sign_size;
      ++__beg;
    }
  else if (__lc->_M_negative_sign_size && __beg != __end
    && *__beg == __lc->_M_negative_sign[0])
    {
      __negative = true;
      __sign_size = __lc->_M_negative_sign_size;
      ++__beg;
    }
  else if (__lc->_M_positive_sign_size
    && !__lc->_M_negative_sign_size)


    __negative = true;
  else if (__mandatory_sign)
    __testvalid = false;
  break;
       case money_base::value:


  for (; __beg != __end; ++__beg)
    {
      const char_type __c = *__beg;
      const char_type* __q = __traits_type::find(__lit_zero,
              10, __c);
      if (__q != 0)
        {
   __res += money_base::_S_atoms[__q - __lit];
   ++__n;
        }
      else if (__c == __lc->_M_decimal_point
        && !__testdecfound)
        {
   if (__lc->_M_frac_digits <= 0)
     break;

   __last_pos = __n;
   __n = 0;
   __testdecfound = true;
        }
      else if (__lc->_M_use_grouping
        && __c == __lc->_M_thousands_sep
        && !__testdecfound)
        {
   if (__n)
     {

       __grouping_tmp += static_cast<char>(__n);
       __n = 0;
     }
   else
     {
       __testvalid = false;
       break;
     }
        }
      else
        break;
    }
  if (__res.empty())
    __testvalid = false;
  break;
       case money_base::space:

  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
    ++__beg;
  else
    __testvalid = false;
       case money_base::none:

  if (__i != 3)
    for (; __beg != __end
    && __ctype.is(ctype_base::space, *__beg); ++__beg);
  break;
       }
   }


 if (__sign_size > 1 && __testvalid)
   {
     const char_type* __sign = __negative ? __lc->_M_negative_sign
                                          : __lc->_M_positive_sign;
     size_type __i = 1;
     for (; __beg != __end && __i < __sign_size
     && *__beg == __sign[__i]; ++__beg, ++__i);

     if (__i != __sign_size)
       __testvalid = false;
   }

 if (__testvalid)
   {

     if (__res.size() > 1)
       {
  const size_type __first = __res.find_first_not_of('0');
  const bool __only_zeros = __first == string::npos;
  if (__first)
    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
       }


     if (__negative && __res[0] != '0')
       __res.insert(__res.begin(), '-');


     if (__grouping_tmp.size())
       {

  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
                         : __n);
  if (!std::__verify_grouping(__lc->_M_grouping,
         __lc->_M_grouping_size,
         __grouping_tmp))
    __err |= ios_base::failbit;
       }


     if (__testdecfound && __n != __lc->_M_frac_digits)
       __testvalid = false;
   }


 if (!__testvalid)
   __err |= ios_base::failbit;
 else
   __units.swap(__res);


 if (__beg == __end)
   __err |= ios_base::eofbit;
 return __beg;
      }
# 360 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, long double& __units) const
    {
      string __str;
      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
              : _M_extract<false>(__beg, __end, __io, __err, __str);
      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, string_type& __digits) const
    {
      typedef typename string::size_type size_type;

      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      string __str;
      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
              : _M_extract<false>(__beg, __end, __io, __err, __str);
      const size_type __len = __str.size();
      if (__len)
 {
   __digits.resize(__len);
   __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
 }
      return __beg;
    }

  template<typename _CharT, typename _OutIter>
    template<bool _Intl>
      _OutIter
      money_put<_CharT, _OutIter>::
      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
  const string_type& __digits) const
      {
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;



 const char_type* __beg = __digits.data();

 money_base::pattern __p;
 const char_type* __sign;
 size_type __sign_size;
 if (!(*__beg == __lit[money_base::_S_minus]))
   {
     __p = __lc->_M_pos_format;
     __sign = __lc->_M_positive_sign;
     __sign_size = __lc->_M_positive_sign_size;
   }
 else
   {
     __p = __lc->_M_neg_format;
     __sign = __lc->_M_negative_sign;
     __sign_size = __lc->_M_negative_sign_size;
     if (__digits.size())
       ++__beg;
   }


 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
        __beg + __digits.size()) - __beg;
 if (__len)
   {



     string_type __value;
     __value.reserve(2 * __len);



     long __paddec = __len - __lc->_M_frac_digits;
     if (__paddec > 0)
         {
  if (__lc->_M_frac_digits < 0)
    __paddec = __len;
    if (__lc->_M_grouping_size)
      {
      __value.assign(2 * __paddec, char_type());
       _CharT* __vend =
        std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
       __lc->_M_grouping,
       __lc->_M_grouping_size,
       __beg, __beg + __paddec);
      __value.erase(__vend - &__value[0]);
      }
    else
    __value.assign(__beg, __paddec);
       }


     if (__lc->_M_frac_digits > 0)
       {
  __value += __lc->_M_decimal_point;
  if (__paddec >= 0)
    __value.append(__beg + __paddec, __lc->_M_frac_digits);
  else
    {

      __value.append(-__paddec, __lit[money_base::_S_zero]);
      __value.append(__beg, __len);
    }
         }


     const ios_base::fmtflags __f = __io.flags()
                                    & ios_base::adjustfield;
     __len = __value.size() + __sign_size;
     __len += ((__io.flags() & ios_base::showbase)
        ? __lc->_M_curr_symbol_size : 0);

     string_type __res;
     __res.reserve(2 * __len);

     const size_type __width = static_cast<size_type>(__io.width());
     const bool __testipad = (__f == ios_base::internal
         && __len < __width);

     for (int __i = 0; __i < 4; ++__i)
       {
  const part __which = static_cast<part>(__p.field[__i]);
  switch (__which)
    {
    case money_base::symbol:
      if (__io.flags() & ios_base::showbase)
        __res.append(__lc->_M_curr_symbol,
       __lc->_M_curr_symbol_size);
      break;
    case money_base::sign:



      if (__sign_size)
        __res += __sign[0];
      break;
    case money_base::value:
      __res += __value;
      break;
    case money_base::space:



      if (__testipad)
        __res.append(__width - __len, __fill);
      else
        __res += __fill;
      break;
    case money_base::none:
      if (__testipad)
        __res.append(__width - __len, __fill);
      break;
    }
       }


     if (__sign_size > 1)
       __res.append(__sign + 1, __sign_size - 1);


     __len = __res.size();
     if (__width > __len)
       {
  if (__f == ios_base::left)

    __res.append(__width - __len, __fill);
  else

    __res.insert(0, __width - __len, __fill);
  __len = __width;
       }


     __s = std::__write(__s, __res.data(), __len);
   }
 __io.width(0);
 return __s;
      }
# 565 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 3
  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    long double __units) const
    {
      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);


      int __cs_size = 64;
      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));


      int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     "%.*Lf", 0, __units);

      if (__len >= __cs_size)
 {
   __cs_size = __len + 1;
   __cs = static_cast<char*>(__builtin_alloca(__cs_size));
   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     "%.*Lf", 0, __units);
 }
# 597 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 3
      string_type __digits(__len, char_type());
      __ctype.widen(__cs, __cs + __len, &__digits[0]);
      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits);
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    const string_type& __digits) const
    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits); }






  template<typename _CharT, typename _InIter>
    time_base::dateorder
    time_get<_CharT, _InIter>::do_date_order() const
    { return time_base::no_order; }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm,
     const _CharT* __format) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const size_t __len = char_traits<_CharT>::length(__format);

      ios_base::iostate __tmperr = ios_base::goodbit;
      for (size_t __i = 0; __beg != __end && __i < __len && !__tmperr; ++__i)
 {
   if (__ctype.narrow(__format[__i], 0) == '%')
     {

       char __c = __ctype.narrow(__format[++__i], 0);
       int __mem = 0;
       if (__c == 'E' || __c == 'O')
  __c = __ctype.narrow(__format[++__i], 0);
       switch (__c)
  {
    const char* __cs;
    _CharT __wcs[10];
  case 'a':

    const char_type* __days1[7];
    __tp._M_days_abbreviated(__days1);
    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
       7, __io, __tmperr);
    break;
  case 'A':

    const char_type* __days2[7];
    __tp._M_days(__days2);
    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
       7, __io, __tmperr);
    break;
  case 'h':
  case 'b':

    const char_type* __months1[12];
    __tp._M_months_abbreviated(__months1);
    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
       __months1, 12, __io, __tmperr);
    break;
  case 'B':

    const char_type* __months2[12];
    __tp._M_months(__months2);
    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
       __months2, 12, __io, __tmperr);
    break;
  case 'c':

    const char_type* __dt[2];
    __tp._M_date_time_formats(__dt);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __dt[0]);
    break;
  case 'd':

    __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
      __io, __tmperr);
    break;
  case 'e':


    if (__ctype.is(ctype_base::space, *__beg))
      __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
        1, __io, __tmperr);
    else
      __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
        2, __io, __tmperr);
    break;
  case 'D':

    __cs = "%m/%d/%y";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs);
    break;
  case 'H':

    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
      __io, __tmperr);
    break;
  case 'I':

    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
      __io, __tmperr);
    break;
  case 'm':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_mon = __mem - 1;
    break;
  case 'M':

    __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
      __io, __tmperr);
    break;
  case 'n':
    if (__ctype.narrow(*__beg, 0) == '\n')
      ++__beg;
    else
      __tmperr |= ios_base::failbit;
    break;
  case 'R':

    __cs = "%H:%M";
    __ctype.widen(__cs, __cs + 6, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs);
    break;
  case 'S':



    __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,



      __io, __tmperr);
    break;
  case 't':
    if (__ctype.narrow(*__beg, 0) == '\t')
      ++__beg;
    else
      __tmperr |= ios_base::failbit;
    break;
  case 'T':

    __cs = "%H:%M:%S";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs);
    break;
  case 'x':

    const char_type* __dates[2];
    __tp._M_date_formats(__dates);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __dates[0]);
    break;
  case 'X':

    const char_type* __times[2];
    __tp._M_time_formats(__times);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __times[0]);
    break;
  case 'y':
  case 'C':

  case 'Y':




    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
    break;
  case 'Z':

    if (__ctype.is(ctype_base::upper, *__beg))
      {
        int __tmp;
        __beg = _M_extract_name(__beg, __end, __tmp,
           __timepunct_cache<_CharT>::_S_timezones,
           14, __io, __tmperr);


        if (__beg != __end && !__tmperr && __tmp == 0
     && (*__beg == __ctype.widen('-')
         || *__beg == __ctype.widen('+')))
   {
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
       __io, __tmperr);
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
       __io, __tmperr);
   }
      }
    else
      __tmperr |= ios_base::failbit;
    break;
  default:

    __tmperr |= ios_base::failbit;
  }
     }
   else
     {

       if (__format[__i] == *__beg)
  ++__beg;
       else
  __tmperr |= ios_base::failbit;
     }
 }

      if (__tmperr)
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
     int __min, int __max, size_t __len,
     ios_base& __io, ios_base::iostate& __err) const
    {
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);


      int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);

      ++__min;
      size_t __i = 0;
      int __value = 0;
      for (; __beg != __end && __i < __len; ++__beg, ++__i)
 {
   const char __c = __ctype.narrow(*__beg, '*');
   if (__c >= '0' && __c <= '9')
     {
       __value = __value * 10 + (__c - '0');
       const int __valuec = __value * __mult;
       if (__valuec > __max || __valuec + __mult < __min)
  break;
       __mult /= 10;
     }
   else
     break;
 }
      if (__i == __len)
 __member = __value;

      else if (__len == 4 && __i == 2)
 __member = __value - 100;
      else
 __err |= ios_base::failbit;

      return __beg;
    }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
      const _CharT** __names, size_t __indexlen,
      ios_base& __io, ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
         * __indexlen));
      size_t __nmatches = 0;
      size_t __pos = 0;
      bool __testvalid = true;
      const char_type* __name;





      if (__beg != __end)
 {
   const char_type __c = *__beg;
   for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
     if (__c == __names[__i1][0]
  || __c == __ctype.toupper(__names[__i1][0]))
       __matches[__nmatches++] = __i1;
 }

      while (__nmatches > 1)
 {

   size_t __minlen = __traits_type::length(__names[__matches[0]]);
   for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
     __minlen = std::min(__minlen,
         __traits_type::length(__names[__matches[__i2]]));
   ++__beg, ++__pos;
   if (__pos < __minlen && __beg != __end)
     for (size_t __i3 = 0; __i3 < __nmatches;)
       {
  __name = __names[__matches[__i3]];
  if (!(__name[__pos] == *__beg))
    __matches[__i3] = __matches[--__nmatches];
  else
    ++__i3;
       }
   else
     break;
 }

      if (__nmatches == 1)
 {

   ++__beg, ++__pos;
   __name = __names[__matches[0]];
   const size_t __len = __traits_type::length(__name);
   while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
     ++__beg, ++__pos;

   if (__len == __pos)
     __member = __matches[0];
   else
     __testvalid = false;
 }
      else
 __testvalid = false;
      if (!__testvalid)
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
        const _CharT** __names, size_t __indexlen,
        ios_base& __io, ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
         * __indexlen));
      size_t __nmatches = 0;
      size_t* __matches_lengths = 0;
      size_t __pos = 0;

      if (__beg != __end)
 {
   const char_type __c = *__beg;
   for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
     if (__c == __names[__i][0]
  || __c == __ctype.toupper(__names[__i][0]))
       __matches[__nmatches++] = __i;
 }

      if (__nmatches)
 {
   ++__beg, ++__pos;

   __matches_lengths
     = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
          * __nmatches));
   for (size_t __i = 0; __i < __nmatches; ++__i)
     __matches_lengths[__i]
       = __traits_type::length(__names[__matches[__i]]);
 }

      for (; __beg != __end; ++__beg, ++__pos)
 {
   size_t __nskipped = 0;
   const char_type __c = *__beg;
   for (size_t __i = 0; __i < __nmatches;)
     {
       const char_type* __name = __names[__matches[__i]];
       if (__pos >= __matches_lengths[__i])
  ++__nskipped, ++__i;
       else if (!(__name[__pos] == __c))
  {
    --__nmatches;
    __matches[__i] = __matches[__nmatches];
    __matches_lengths[__i] = __matches_lengths[__nmatches];
  }
       else
  ++__i;
     }
   if (__nskipped == __nmatches)
     break;
 }

      if ((__nmatches == 1 && __matches_lengths[0] == __pos)
   || (__nmatches == 2 && (__matches_lengths[0] == __pos
      || __matches_lengths[1] == __pos)))
 __member = (__matches[0] >= __indexlen
      ? __matches[0] - __indexlen : __matches[0]);
      else
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __times[2];
      __tp._M_time_formats(__times);
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __times[0]);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __dates[2];
      __tp._M_date_formats(__dates);
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __dates[0]);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const char_type* __days[14];
      __tp._M_days_abbreviated(__days);
      __tp._M_days(__days + 7);
      int __tmpwday;
      ios_base::iostate __tmperr = ios_base::goodbit;

      __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
           __io, __tmperr);
      if (!__tmperr)
 __tm->tm_wday = __tmpwday;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
     }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_monthname(iter_type __beg, iter_type __end,
                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const char_type* __months[24];
      __tp._M_months_abbreviated(__months);
      __tp._M_months(__months + 12);
      int __tmpmon;
      ios_base::iostate __tmperr = ios_base::goodbit;

      __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
           __io, __tmperr);
      if (!__tmperr)
 __tm->tm_mon = __tmpmon;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      int __tmpyear;
      ios_base::iostate __tmperr = ios_base::goodbit;

      __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
        __io, __tmperr);
      if (!__tmperr)
 __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
 const _CharT* __beg, const _CharT* __end) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      for (; __beg != __end; ++__beg)
 if (__ctype.narrow(*__beg, 0) != '%')
   {
     *__s = *__beg;
     ++__s;
   }
 else if (++__beg != __end)
   {
     char __format;
     char __mod = 0;
     const char __c = __ctype.narrow(*__beg, 0);
     if (__c != 'E' && __c != 'O')
       __format = __c;
     else if (++__beg != __end)
       {
  __mod = __c;
  __format = __ctype.narrow(*__beg, 0);
       }
     else
       break;
     __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
   }
 else
   break;
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
    char __format, char __mod) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);



      const size_t __maxlen = 128;
      char_type __res[__maxlen];






      char_type __fmt[4];
      __fmt[0] = __ctype.widen('%');
      if (!__mod)
 {
   __fmt[1] = __format;
   __fmt[2] = char_type();
 }
      else
 {
   __fmt[1] = __mod;
   __fmt[2] = __format;
   __fmt[3] = char_type();
 }

      __tp._M_put(__res, __maxlen, __fmt, __tm);


      return std::__write(__s, __res, char_traits<char_type>::length(__res));
    }






  extern template class moneypunct<char, false>;
  extern template class moneypunct<char, true>;
  extern template class moneypunct_byname<char, false>;
  extern template class moneypunct_byname<char, true>;
  extern template class money_get<char>;
  extern template class money_put<char>;
  extern template class __timepunct<char>;
  extern template class time_put<char>;
  extern template class time_put_byname<char>;
  extern template class time_get<char>;
  extern template class time_get_byname<char>;
  extern template class messages<char>;
  extern template class messages_byname<char>;

  extern template
    const moneypunct<char, true>&
    use_facet<moneypunct<char, true> >(const locale&);

  extern template
    const moneypunct<char, false>&
    use_facet<moneypunct<char, false> >(const locale&);

  extern template
    const money_put<char>&
    use_facet<money_put<char> >(const locale&);

  extern template
    const money_get<char>&
    use_facet<money_get<char> >(const locale&);

  extern template
    const __timepunct<char>&
    use_facet<__timepunct<char> >(const locale&);

  extern template
    const time_put<char>&
    use_facet<time_put<char> >(const locale&);

  extern template
    const time_get<char>&
    use_facet<time_get<char> >(const locale&);

  extern template
    const messages<char>&
    use_facet<messages<char> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<char> >(const locale&);

  extern template
    bool
    has_facet<money_put<char> >(const locale&);

  extern template
    bool
    has_facet<money_get<char> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<char> >(const locale&);

  extern template
    bool
    has_facet<time_put<char> >(const locale&);

  extern template
    bool
    has_facet<time_get<char> >(const locale&);

  extern template
    bool
    has_facet<messages<char> >(const locale&);


  extern template class moneypunct<wchar_t, false>;
  extern template class moneypunct<wchar_t, true>;
  extern template class moneypunct_byname<wchar_t, false>;
  extern template class moneypunct_byname<wchar_t, true>;
  extern template class money_get<wchar_t>;
  extern template class money_put<wchar_t>;
  extern template class __timepunct<wchar_t>;
  extern template class time_put<wchar_t>;
  extern template class time_put_byname<wchar_t>;
  extern template class time_get<wchar_t>;
  extern template class time_get_byname<wchar_t>;
  extern template class messages<wchar_t>;
  extern template class messages_byname<wchar_t>;

  extern template
    const moneypunct<wchar_t, true>&
    use_facet<moneypunct<wchar_t, true> >(const locale&);

  extern template
    const moneypunct<wchar_t, false>&
    use_facet<moneypunct<wchar_t, false> >(const locale&);

  extern template
    const money_put<wchar_t>&
    use_facet<money_put<wchar_t> >(const locale&);

  extern template
    const money_get<wchar_t>&
    use_facet<money_get<wchar_t> >(const locale&);

  extern template
    const __timepunct<wchar_t>&
    use_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    const time_put<wchar_t>&
    use_facet<time_put<wchar_t> >(const locale&);

  extern template
    const time_get<wchar_t>&
    use_facet<time_get<wchar_t> >(const locale&);

  extern template
    const messages<wchar_t>&
    use_facet<messages<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<messages<wchar_t> >(const locale&);



}
# 1931 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 2 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/locale" 2 3
# 36 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 2
# 55 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
namespace boost
{

    class bad_lexical_cast : public std::bad_cast






    {
    public:
        bad_lexical_cast() :

          source(&typeid(void)), target(&typeid(void))



        {
        }

        bad_lexical_cast(
            const std::type_info &source_type_arg,
            const std::type_info &target_type_arg) :
            source(&source_type_arg), target(&target_type_arg)
        {
        }

        const std::type_info &source_type() const
        {
            return *source;
        }
        const std::type_info &target_type() const
        {
            return *target;
        }

        virtual const char *what() const throw()
        {
            return "bad lexical cast: "
                   "source type value could not be interpreted as target";
        }
        virtual ~bad_lexical_cast() throw()
        {
        }
    private:
        const std::type_info *source;
        const std::type_info *target;
    };

    namespace detail
    {
        template<typename Type>
        struct stream_char
        {
            typedef char type;
        };


        template<class CharT, class Traits, class Alloc>
        struct stream_char< std::basic_string<CharT,Traits,Alloc> >
        {
            typedef CharT type;
        };




        template<>
        struct stream_char<wchar_t>
        {
            typedef wchar_t type;
        };


        template<>
        struct stream_char<wchar_t *>
        {
            typedef wchar_t type;
        };

        template<>
        struct stream_char<const wchar_t *>
        {
            typedef wchar_t type;
        };
# 151 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
        template<typename TargetChar, typename SourceChar>
        struct widest_char
        {
            typedef TargetChar type;
        };

        template<>
        struct widest_char<char, wchar_t>
        {
            typedef wchar_t type;
        };
    }

    namespace detail
    {

        template<class CharT, class Target, class Source>
        struct deduce_char_traits
        {
            typedef std::char_traits<CharT> type;
        };

        template<class CharT, class Traits, class Alloc, class Source>
        struct deduce_char_traits< CharT
                                 , std::basic_string<CharT,Traits,Alloc>
                                 , Source
                                 >
        {
            typedef Traits type;
        };

        template<class CharT, class Target, class Traits, class Alloc>
        struct deduce_char_traits< CharT
                                 , Target
                                 , std::basic_string<CharT,Traits,Alloc>
                                 >
        {
            typedef Traits type;
        };

        template<class CharT, class Traits, class Alloc1, class Alloc2>
        struct deduce_char_traits< CharT
                                 , std::basic_string<CharT,Traits,Alloc1>
                                 , std::basic_string<CharT,Traits,Alloc2>
                                 >
        {
            typedef Traits type;
        };

    }

    namespace detail
    {
# 213 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
        template< class CharT
                , class Source
                >
        struct lcast_src_length
        {
            static const std::size_t value = 0;


            static void check_coverage() {}
        };

        template<>
        struct lcast_src_length<char, bool>
        {
            static const std::size_t value = 1;
            static void check_coverage() {}
        };

        template<>
        struct lcast_src_length<char, char>
        {
            static const std::size_t value = 1;
            static void check_coverage() {}
        };
# 247 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
        template<>
        struct lcast_src_length<wchar_t, bool>
        {
            static const std::size_t value = 1;
            static void check_coverage() {}
        };

        template<>
        struct lcast_src_length<wchar_t, char>
        {
            static const std::size_t value = 1;
            static void check_coverage() {}
        };


        template<>
        struct lcast_src_length<wchar_t, wchar_t>
        {
            static const std::size_t value = 1;
            static void check_coverage() {}
        };



        template<>
        struct lcast_src_length<char, char const*>
        {
            static const std::size_t value = 1;
            static void check_coverage() {}
        };

        template<>
        struct lcast_src_length<char, char*>
        {
            static const std::size_t value = 1;
            static void check_coverage() {}
        };


        template<>
        struct lcast_src_length<wchar_t, wchar_t const*>
        {
            static const std::size_t value = 1;
            static void check_coverage() {}
        };

        template<>
        struct lcast_src_length<wchar_t, wchar_t*>
        {
            static const std::size_t value = 1;
            static void check_coverage() {}
        };



        template<class CharT, class Traits, class Alloc>
        struct lcast_src_length< CharT, std::basic_string<CharT,Traits,Alloc> >
        {
            static const std::size_t value = 1;
            static void check_coverage() {}
        };
# 339 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
        template<class Source>
        struct lcast_src_length_integral
        {

            static const std::size_t value = std::numeric_limits<Source>::is_signed + std::numeric_limits<Source>::is_specialized + std::numeric_limits<Source>::digits10 * 2



               ;




        };
# 367 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
        template<> struct lcast_src_length<char, short> : lcast_src_length_integral<short> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, short> : lcast_src_length_integral<short> { static void check_coverage() {} };
        template<> struct lcast_src_length<char, unsigned short> : lcast_src_length_integral<unsigned short> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, unsigned short> : lcast_src_length_integral<unsigned short> { static void check_coverage() {} };
        template<> struct lcast_src_length<char, int> : lcast_src_length_integral<int> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, int> : lcast_src_length_integral<int> { static void check_coverage() {} };
        template<> struct lcast_src_length<char, unsigned int> : lcast_src_length_integral<unsigned int> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, unsigned int> : lcast_src_length_integral<unsigned int> { static void check_coverage() {} };
        template<> struct lcast_src_length<char, long> : lcast_src_length_integral<long> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, long> : lcast_src_length_integral<long> { static void check_coverage() {} };
        template<> struct lcast_src_length<char, unsigned long> : lcast_src_length_integral<unsigned long> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, unsigned long> : lcast_src_length_integral<unsigned long> { static void check_coverage() {} };

        template<> struct lcast_src_length<char, boost::ulong_long_type> : lcast_src_length_integral<boost::ulong_long_type> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, boost::ulong_long_type> : lcast_src_length_integral<boost::ulong_long_type> { static void check_coverage() {} };
        template<> struct lcast_src_length<char, boost::long_long_type> : lcast_src_length_integral<boost::long_long_type> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, boost::long_long_type> : lcast_src_length_integral<boost::long_long_type> { static void check_coverage() {} };
# 395 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
        template<class Source>
        struct lcast_src_length_floating
        {
            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((std::numeric_limits<Source>::max_exponent10 <= 999999L && std::numeric_limits<Source>::min_exponent10 >= -999999L) == 0 ? false : true) >)>


 boost_static_assert_typedef_401;
            static const std::size_t value = 5 + lcast_precision<Source>::value + 6

                 ;
        };

        template<>
        struct lcast_src_length<char,float>
          : lcast_src_length_floating<float>
        {
            static void check_coverage() {}
        };

        template<>
        struct lcast_src_length<char,double>
          : lcast_src_length_floating<double>
        {
            static void check_coverage() {}
        };

        template<>
        struct lcast_src_length<char,long double>
          : lcast_src_length_floating<long double>
        {
            static void check_coverage() {}
        };


    template<>
    struct lcast_src_length<wchar_t,float>
      : lcast_src_length_floating<float>
    {
        static void check_coverage() {}
    };

    template<>
    struct lcast_src_length<wchar_t,double>
      : lcast_src_length_floating<double>
    {
        static void check_coverage() {}
    };

    template<>
    struct lcast_src_length<wchar_t,long double>
      : lcast_src_length_floating<long double>
    {
        static void check_coverage() {}
    };



    }

    namespace detail
    {
        template<typename CharT> struct lcast_char_constants;

        template<>
        struct lcast_char_constants<char>
        {
            static const char zero = '0';
            static const char minus = '-';
        };


        template<>
        struct lcast_char_constants<wchar_t>
        {
            static const wchar_t zero = L'0';
            static const wchar_t minus = L'-';
        };

    }

    namespace detail
    {
        struct lexical_streambuf_fake
        {
        };
    }

    namespace detail
    {







        template<class T>
        inline
        typename make_unsigned<T>::type lcast_to_unsigned(T value)
        {
            typedef typename make_unsigned<T>::type result_type;
            result_type uvalue = static_cast<result_type>(value);
            return value < 0 ? -uvalue : uvalue;
        }





    }

    namespace detail
    {
        template<class Traits, class T, class CharT>
        CharT* lcast_put_unsigned(T n, CharT* finish)
        {

            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!std::numeric_limits<T>::is_signed) == 0 ? false : true) >)> boost_static_assert_typedef_512;




            std::locale loc;
            typedef std::numpunct<CharT> numpunct;
            numpunct const& np = std::use_facet< numpunct >(loc);
            std::string const& grouping = np.grouping();
            std::string::size_type const grouping_size = grouping.size();
            CharT thousands_sep = grouping_size ? np.thousands_sep() : 0;
            std::string::size_type group = 0;
            char last_grp_size = grouping[0] <= 0 ? 127 : grouping[0];




            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((std::numeric_limits<T>::digits10 < 127) == 0 ? false : true) >)> boost_static_assert_typedef_529;


            char left = last_grp_size;


            typedef typename Traits::int_type int_type;
            CharT const czero = lcast_char_constants<CharT>::zero;
            int_type const zero = Traits::to_int_type(czero);

            do
            {

                if(left == 0)
                {
                    ++group;
                    if(group < grouping_size)
                    {
                        char const grp_size = grouping[group];
                        last_grp_size = grp_size <= 0 ? 127 : grp_size;
                    }

                    left = last_grp_size;
                    --finish;
                    Traits::assign(*finish, thousands_sep);
                }

                --left;


                --finish;
                int_type const digit = static_cast<int_type>(n % 10U);
                Traits::assign(*finish, Traits::to_char_type(zero + digit));
                n /= 10;
            } while(n);

            return finish;
        }
    }

    namespace detail
    {
        template<typename Target, typename Source, typename Traits>
        class lexical_stream
        {
        private:
            typedef typename widest_char<
                typename stream_char<Target>::type,
                typename stream_char<Source>::type>::type char_type;

            typedef Traits traits_type;

        public:
            lexical_stream(char_type* = 0, char_type* = 0)
            {
                stream.unsetf(std::ios::skipws);
                lcast_set_precision(stream, static_cast<Source*>(0), static_cast<Target*>(0) );
            }
            ~lexical_stream()
            {



            }
            bool operator<<(const Source &input)
            {
                return !(stream << input).fail();
            }
            template<typename InputStreamable>
            bool operator>>(InputStreamable &output)
            {
                return !is_pointer<InputStreamable>::value &&
                       stream >> output &&
                       stream.get() ==







                           traits_type::eof();

            }
# 633 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
            bool operator>>(std::basic_string<char_type,traits_type>& output)
            {
                stream.str().swap(output);
                return true;
            }

            template<class Alloc>
            bool operator>>(std::basic_string<char_type,traits_type,Alloc>& out)
            {
                std::basic_string<char_type,traits_type> str(stream.str());
                out.assign(str.begin(), str.end());
                return true;
            }

        private:





            std::basic_stringstream<char_type,traits_type> stream;

        };
    }

    namespace detail
    {

        template< class CharT
                , class Base
                , class Traits
                >
        class lexical_stream_limited_src : public Base
        {



            CharT* start;
            CharT* finish;

        private:

            static void widen_and_assign(char*p, char ch)
            {
                Traits::assign(*p, ch);
            }


            static void widen_and_assign(wchar_t* p, char ch)
            {

                std::locale loc;
                wchar_t w = std::use_facet< std::ctype<wchar_t> >(loc).widen(ch);
                Traits::assign(*p, w);
            }

            static void widen_and_assign(wchar_t* p, wchar_t ch)
            {
                Traits::assign(*p, ch);
            }

            static void widen_and_assign(char*, wchar_t ch);


            template<class OutputStreamable>
            bool lcast_put(const OutputStreamable& input)
            {
                this->setp(start, finish);
                std::basic_ostream<CharT> stream(static_cast<Base*>(this));
                lcast_set_precision(stream, static_cast<OutputStreamable*>(0));
                bool const result = !(stream << input).fail();
                finish = this->pptr();
                return result;
            }


            lexical_stream_limited_src(lexical_stream_limited_src const&);
            void operator=(lexical_stream_limited_src const&);

        public:

            lexical_stream_limited_src(CharT* sta, CharT* fin)
              : start(sta)
              , finish(fin)
            {}

        public:

            template<class Alloc>
            bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str)
            {
                start = const_cast<CharT*>(str.data());
                finish = start + str.length();
                return true;
            }

            bool operator<<(bool);
            bool operator<<(char);

            bool operator<<(wchar_t);

            bool operator<<(CharT const*);
            bool operator<<(short);
            bool operator<<(int);
            bool operator<<(long);
            bool operator<<(unsigned short);
            bool operator<<(unsigned int);
            bool operator<<(unsigned long);

            bool operator<<(boost::ulong_long_type);
            bool operator<<(boost::long_long_type );






            bool operator<<(float);
            bool operator<<(double);
            bool operator<<(long double);

        public:



            template<typename InputStreamable>
            bool operator>>(InputStreamable& output)
            {





                if(is_pointer<InputStreamable>::value)
                    return false;

                this->setg(start, start, finish);
                std::basic_istream<CharT> stream(static_cast<Base*>(this));
                stream.unsetf(std::ios::skipws);
                lcast_set_precision(stream, static_cast<InputStreamable*>(0));



                return stream >> output &&
                    stream.get() ==







                Traits::eof();

            }

            bool operator>>(CharT&);
# 801 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
            template<class Alloc>
            bool operator>>(std::basic_string<CharT,Traits,Alloc>& str)
            {
                str.assign(start, finish);
                return true;
            }

        };

        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                bool value)
        {
            typedef typename Traits::int_type int_type;
            CharT const czero = lcast_char_constants<CharT>::zero;
            int_type const zero = Traits::to_int_type(czero);
            Traits::assign(*start, Traits::to_char_type(zero + value));
            finish = start + 1;
            return true;
        }

        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                char ch)
        {
            widen_and_assign(start, ch);
            finish = start + 1;
            return true;
        }


        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                wchar_t ch)
        {
            widen_and_assign(start, ch);
            finish = start + 1;
            return true;
        }


        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                short n)
        {
            start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
            if(n < 0)
            {
                --start;
                CharT const minus = lcast_char_constants<CharT>::minus;
                Traits::assign(*start, minus);
            }
            return true;
        }

        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                int n)
        {
            start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
            if(n < 0)
            {
                --start;
                CharT const minus = lcast_char_constants<CharT>::minus;
                Traits::assign(*start, minus);
            }
            return true;
        }

        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                long n)
        {
            start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
            if(n < 0)
            {
                --start;
                CharT const minus = lcast_char_constants<CharT>::minus;
                Traits::assign(*start, minus);
            }
            return true;
        }


        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                boost::long_long_type n)
        {
            start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
            if(n < 0)
            {
                --start;
                CharT const minus = lcast_char_constants<CharT>::minus;
                Traits::assign(*start, minus);
            }
            return true;
        }
# 914 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                unsigned short n)
        {
            start = lcast_put_unsigned<Traits>(n, finish);
            return true;
        }

        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                unsigned int n)
        {
            start = lcast_put_unsigned<Traits>(n, finish);
            return true;
        }

        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                unsigned long n)
        {
            start = lcast_put_unsigned<Traits>(n, finish);
            return true;
        }


        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                boost::ulong_long_type n)
        {
            start = lcast_put_unsigned<Traits>(n, finish);
            return true;
        }
# 956 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                float val)
        {
            return this->lcast_put(val);
        }

        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                double val)
        {
            return this->lcast_put(val);
        }

        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                long double val)
        {
            return this->lcast_put(val);
        }

        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
                CharT const* str)
        {
            start = const_cast<CharT*>(str);
            finish = start + Traits::length(str);
            return true;
        }

        template<typename CharT, class Base, class Traits>
        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator>>(
                CharT& output)
        {
            bool const ok = (finish - start == 1);
            if(ok)
                Traits::assign(output, *start);
            return ok;
        }
# 1015 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
    }

    namespace detail
    {

        template<class Source>
        struct lcast_streambuf_for_source
        {
            static const bool value = false;
        };

        template<>
        struct lcast_streambuf_for_source<float>
        {
            static const bool value = true;
        };

        template<>
        struct lcast_streambuf_for_source<double>
        {
            static const bool value = true;
        };

        template<>
        struct lcast_streambuf_for_source<long double>
        {
            static const bool value = true;
        };
    }

    namespace detail
    {

        template<class Target>
        struct lcast_streambuf_for_target
        {
            static const bool value = true;
        };

        template<>
        struct lcast_streambuf_for_target<char>
        {
            static const bool value = false;
        };


        template<>
        struct lcast_streambuf_for_target<wchar_t>
        {
            static const bool value = false;
        };



        template<class Traits, class Alloc>
        struct lcast_streambuf_for_target<
                    std::basic_string<char,Traits,Alloc> >
        {
            static const bool value = false;
        };


        template<class Traits, class Alloc>
        struct lcast_streambuf_for_target<
                    std::basic_string<wchar_t,Traits,Alloc> >
        {
            static const bool value = false;
        };
# 1099 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
    }





    namespace detail
    {
        template<class T>
        struct array_to_pointer_decay
        {
            typedef T type;
        };

        template<class T, std::size_t N>
        struct array_to_pointer_decay<T[N]>
        {
            typedef const T * type;
        };







        template< typename Target
                , typename Source
                , bool Unlimited
                , typename CharT
                >
        Target lexical_cast(
            typename boost::call_traits<Source>::param_type arg,
            CharT* buf, std::size_t src_len)
        {
            typedef typename
                deduce_char_traits<CharT,Target,Source>::type traits;

            typedef typename boost::mpl::if_c<
                lcast_streambuf_for_target<Target>::value ||
                lcast_streambuf_for_source<Source>::value
              , std::basic_streambuf<CharT>
              , lexical_streambuf_fake
              >::type base;

            typename boost::mpl::if_c<
                Unlimited
              , detail::lexical_stream<Target,Source,traits>
              , detail::lexical_stream_limited_src<CharT,base,traits>
              >::type interpreter(buf, buf + src_len);

            Target result;
            if(!(interpreter << arg && interpreter >> result))
                throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)));
            return result;
        }



    }

    template<typename Target, typename Source>
    inline Target lexical_cast(const Source &arg)
    {
        typedef typename detail::array_to_pointer_decay<Source>::type src;

        typedef typename detail::widest_char<
            typename detail::stream_char<Target>::type
          , typename detail::stream_char<src>::type
          >::type char_type;

        typedef detail::lcast_src_length<char_type, src> lcast_src_length;
        std::size_t const src_len = lcast_src_length::value;
        char_type buf[src_len + 1];
        lcast_src_length::check_coverage();
        return detail::lexical_cast<Target, src, !src_len>(arg, buf, src_len);
    }
# 1203 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
}
# 20 "/usr/include/boost-1_42/boost/python/operators.hpp" 2





namespace boost { namespace python {

namespace detail
{


  template <class T>
  PyObject* convert_result(T const& x)
  {
      return converter::arg_to_python<T>(x).release();
  }



  template <operator_id> struct operator_l
  {
      template <class L, class R> struct apply;
  };

  template <operator_id> struct operator_r
  {
      template <class L, class R> struct apply;
  };

  template <operator_id> struct operator_1
  {
      template <class T> struct apply;
  };




  template <operator_id id, class L, class R>
  struct operator_l_inner
      : operator_l<id>::template apply<L,R>
  {};

  template <operator_id id, class L, class R>
  struct operator_r_inner
      : operator_r<id>::template apply<L,R>
  {};

  template <operator_id id, class T>
  struct operator_1_inner
      : operator_1<id>::template apply<T>
  {};
# 84 "/usr/include/boost-1_42/boost/python/operators.hpp"
  template <operator_id id>
  struct binary_op : operator_l<id>
  {
      template <class T>
      struct apply : operator_l_inner<id,T,T>
      {
      };
  };


  template <operator_id id, class R>
  struct binary_op_l : operator_l<id>
  {
      template <class T>
      struct apply : operator_l_inner<id,T,R>
      {
      };
  };


  template <operator_id id, class L>
  struct binary_op_r : operator_r<id>
  {
      template <class T>
      struct apply : operator_r_inner<id,L,T>
      {
      };
  };

  template <operator_id id>
  struct unary_op : operator_1<id>
  {
      template <class T>
      struct apply : operator_1_inner<id,T>
      {
      };
  };



  template <operator_id id, class L = not_specified, class R = not_specified>
  struct operator_
    : def_visitor<operator_<id,L,R> >
  {
   private:
      template <class ClassT>
      void visit(ClassT& cl) const
      {
          typedef typename mpl::eval_if<
              is_same<L,self_t>
            , mpl::if_<
                  is_same<R,self_t>
                , binary_op<id>
                , binary_op_l<
                      id
                    , typename unwrap_other<R>::type
                  >
              >
            , mpl::if_<
                  is_same<L,not_specified>
                , unary_op<id>
                , binary_op_r<
                      id
                    , typename unwrap_other<L>::type
                  >
              >
          >::type generator;

          cl.def(
              generator::name()
            , &generator::template apply<
                 typename ClassT::wrapped_type
              >::execute
          );
      }

      friend class python::def_visitor_access;
  };
}
# 212 "/usr/include/boost-1_42/boost/python/operators.hpp"
namespace detail { template <> struct operator_l<op_add> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l + r); } }; static char const* name() { return "__" "add" "__"; } }; template <> struct operator_r<op_add> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l + r); } }; static char const* name() { return "__" "radd" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_add,L,R> operator +(L const&, R const&) { return detail::operator_<detail::op_add,L,R>(); } }
namespace detail { template <> struct operator_l<op_sub> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l - r); } }; static char const* name() { return "__" "sub" "__"; } }; template <> struct operator_r<op_sub> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l - r); } }; static char const* name() { return "__" "rsub" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_sub,L,R> operator -(L const&, R const&) { return detail::operator_<detail::op_sub,L,R>(); } }
namespace detail { template <> struct operator_l<op_mul> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l * r); } }; static char const* name() { return "__" "mul" "__"; } }; template <> struct operator_r<op_mul> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l * r); } }; static char const* name() { return "__" "rmul" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_mul,L,R> operator *(L const&, R const&) { return detail::operator_<detail::op_mul,L,R>(); } }
namespace detail { template <> struct operator_l<op_div> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l / r); } }; static char const* name() { return "__" "div" "__"; } }; template <> struct operator_r<op_div> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l / r); } }; static char const* name() { return "__" "rdiv" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_div,L,R> operator /(L const&, R const&) { return detail::operator_<detail::op_div,L,R>(); } }
namespace detail { template <> struct operator_l<op_mod> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l % r); } }; static char const* name() { return "__" "mod" "__"; } }; template <> struct operator_r<op_mod> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l % r); } }; static char const* name() { return "__" "rmod" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_mod,L,R> operator %(L const&, R const&) { return detail::operator_<detail::op_mod,L,R>(); } }
namespace detail { template <> struct operator_l<op_lshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l << r); } }; static char const* name() { return "__" "lshift" "__"; } }; template <> struct operator_r<op_lshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l << r); } }; static char const* name() { return "__" "rlshift" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_lshift,L,R> operator <<(L const&, R const&) { return detail::operator_<detail::op_lshift,L,R>(); } }
namespace detail { template <> struct operator_l<op_rshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l >> r); } }; static char const* name() { return "__" "rshift" "__"; } }; template <> struct operator_r<op_rshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l >> r); } }; static char const* name() { return "__" "rrshift" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_rshift,L,R> operator >>(L const&, R const&) { return detail::operator_<detail::op_rshift,L,R>(); } }
namespace detail { template <> struct operator_l<op_and> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l & r); } }; static char const* name() { return "__" "and" "__"; } }; template <> struct operator_r<op_and> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l & r); } }; static char const* name() { return "__" "rand" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_and,L,R> operator &(L const&, R const&) { return detail::operator_<detail::op_and,L,R>(); } }
namespace detail { template <> struct operator_l<op_xor> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l ^ r); } }; static char const* name() { return "__" "xor" "__"; } }; template <> struct operator_r<op_xor> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l ^ r); } }; static char const* name() { return "__" "rxor" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_xor,L,R> operator ^(L const&, R const&) { return detail::operator_<detail::op_xor,L,R>(); } }
namespace detail { template <> struct operator_l<op_or> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l | r); } }; static char const* name() { return "__" "or" "__"; } }; template <> struct operator_r<op_or> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l | r); } }; static char const* name() { return "__" "ror" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_or,L,R> operator |(L const&, R const&) { return detail::operator_<detail::op_or,L,R>(); } }
namespace detail { template <> struct operator_l<op_gt> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l > r); } }; static char const* name() { return "__" "gt" "__"; } }; template <> struct operator_r<op_gt> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l > r); } }; static char const* name() { return "__" "lt" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_gt,L,R> operator >(L const&, R const&) { return detail::operator_<detail::op_gt,L,R>(); } }
namespace detail { template <> struct operator_l<op_ge> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l >= r); } }; static char const* name() { return "__" "ge" "__"; } }; template <> struct operator_r<op_ge> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l >= r); } }; static char const* name() { return "__" "le" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_ge,L,R> operator >=(L const&, R const&) { return detail::operator_<detail::op_ge,L,R>(); } }
namespace detail { template <> struct operator_l<op_lt> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l < r); } }; static char const* name() { return "__" "lt" "__"; } }; template <> struct operator_r<op_lt> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l < r); } }; static char const* name() { return "__" "gt" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_lt,L,R> operator <(L const&, R const&) { return detail::operator_<detail::op_lt,L,R>(); } }
namespace detail { template <> struct operator_l<op_le> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l <= r); } }; static char const* name() { return "__" "le" "__"; } }; template <> struct operator_r<op_le> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l <= r); } }; static char const* name() { return "__" "ge" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_le,L,R> operator <=(L const&, R const&) { return detail::operator_<detail::op_le,L,R>(); } }
namespace detail { template <> struct operator_l<op_eq> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l == r); } }; static char const* name() { return "__" "eq" "__"; } }; template <> struct operator_r<op_eq> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l == r); } }; static char const* name() { return "__" "eq" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_eq,L,R> operator ==(L const&, R const&) { return detail::operator_<detail::op_eq,L,R>(); } }
namespace detail { template <> struct operator_l<op_ne> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l != r); } }; static char const* name() { return "__" "ne" "__"; } }; template <> struct operator_r<op_ne> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l != r); } }; static char const* name() { return "__" "ne" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_ne,L,R> operator !=(L const&, R const&) { return detail::operator_<detail::op_ne,L,R>(); } }



namespace detail { template <> struct operator_l<op_pow> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(pow(l,r)); } }; static char const* name() { return "__" "pow" "__"; } }; template <> struct operator_r<op_pow> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(pow(l,r)); } }; static char const* name() { return "__" "rpow" "__"; } }; }


namespace self_ns
{

  template <class L, class R>
  inline detail::operator_<detail::op_pow,L,R>
  pow(L const&, R const&)
  {
      return detail::operator_<detail::op_pow,L,R>();
  }
# 267 "/usr/include/boost-1_42/boost/python/operators.hpp"
}
# 301 "/usr/include/boost-1_42/boost/python/operators.hpp"
namespace detail { template <> struct operator_l<op_iadd> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() += r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "iadd" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_iadd,self_t,R> operator +=(self_t const&, R const&) { return detail::operator_<detail::op_iadd,self_t,R>(); } }
namespace detail { template <> struct operator_l<op_isub> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() -= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "isub" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_isub,self_t,R> operator -=(self_t const&, R const&) { return detail::operator_<detail::op_isub,self_t,R>(); } }
namespace detail { template <> struct operator_l<op_imul> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() *= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "imul" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_imul,self_t,R> operator *=(self_t const&, R const&) { return detail::operator_<detail::op_imul,self_t,R>(); } }
namespace detail { template <> struct operator_l<op_idiv> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() /= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "idiv" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_idiv,self_t,R> operator /=(self_t const&, R const&) { return detail::operator_<detail::op_idiv,self_t,R>(); } }
namespace detail { template <> struct operator_l<op_imod> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() %= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "imod" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_imod,self_t,R> operator %=(self_t const&, R const&) { return detail::operator_<detail::op_imod,self_t,R>(); } }
namespace detail { template <> struct operator_l<op_ilshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() <<= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "ilshift" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_ilshift,self_t,R> operator <<=(self_t const&, R const&) { return detail::operator_<detail::op_ilshift,self_t,R>(); } }
namespace detail { template <> struct operator_l<op_irshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() >>= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "irshift" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_irshift,self_t,R> operator >>=(self_t const&, R const&) { return detail::operator_<detail::op_irshift,self_t,R>(); } }
namespace detail { template <> struct operator_l<op_iand> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() &= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "iand" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_iand,self_t,R> operator &=(self_t const&, R const&) { return detail::operator_<detail::op_iand,self_t,R>(); } }
namespace detail { template <> struct operator_l<op_ixor> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() ^= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "ixor" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_ixor,self_t,R> operator ^=(self_t const&, R const&) { return detail::operator_<detail::op_ixor,self_t,R>(); } }
namespace detail { template <> struct operator_l<op_ior> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() |= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "ior" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_ior,self_t,R> operator |=(self_t const&, R const&) { return detail::operator_<detail::op_ior,self_t,R>(); } }
# 340 "/usr/include/boost-1_42/boost/python/operators.hpp"
namespace detail { template <> struct operator_1<op_neg> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(-(x)); } }; static char const* name() { return "__" "neg" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_neg> operator-(self_t const&) { return detail::operator_<detail::op_neg>(); } }
namespace detail { template <> struct operator_1<op_pos> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(+(x)); } }; static char const* name() { return "__" "pos" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_pos> operator+(self_t const&) { return detail::operator_<detail::op_pos>(); } }
namespace detail { template <> struct operator_1<op_abs> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(abs(x)); } }; static char const* name() { return "__" "abs" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_abs> abs(self_t const&) { return detail::operator_<detail::op_abs>(); } }
namespace detail { template <> struct operator_1<op_invert> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(~(x)); } }; static char const* name() { return "__" "invert" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_invert> operator~(self_t const&) { return detail::operator_<detail::op_invert>(); } }



namespace detail { template <> struct operator_1<op_nonzero> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(!!(x)); } }; static char const* name() { return "__" "nonzero" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_nonzero> operator!(self_t const&) { return detail::operator_<detail::op_nonzero>(); } }

namespace detail { template <> struct operator_1<op_int> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(long(x)); } }; static char const* name() { return "__" "int" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_int> int_(self_t const&) { return detail::operator_<detail::op_int>(); } }
namespace detail { template <> struct operator_1<op_long> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(PyLong_FromLong(x)); } }; static char const* name() { return "__" "long" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_long> long_(self_t const&) { return detail::operator_<detail::op_long>(); } }
namespace detail { template <> struct operator_1<op_float> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(double(x)); } }; static char const* name() { return "__" "float" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_float> float_(self_t const&) { return detail::operator_<detail::op_float>(); } }
namespace detail { template <> struct operator_1<op_complex> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(std::complex<double>(x)); } }; static char const* name() { return "__" "complex" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_complex> complex_(self_t const&) { return detail::operator_<detail::op_complex>(); } }
namespace detail { template <> struct operator_1<op_str> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(lexical_cast<std::string>(x)); } }; static char const* name() { return "__" "str" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_str> str(self_t const&) { return detail::operator_<detail::op_str>(); } }
namespace detail { template <> struct operator_1<op_repr> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(lexical_cast<std::string>(x)); } }; static char const* name() { return "__" "repr" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_repr> repr(self_t const&) { return detail::operator_<detail::op_repr>(); } }


}}
# 51 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/overloads.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/overloads.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/repeat_from_to.hpp" 1
# 15 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp" 2



# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple.hpp" 1
# 20 "/usr/include/boost-1_42/boost/preprocessor/tuple.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/reverse.hpp" 1
# 21 "/usr/include/boost-1_42/boost/preprocessor/tuple.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/to_seq.hpp" 1
# 23 "/usr/include/boost-1_42/boost/preprocessor/tuple.hpp" 2
# 19 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp" 2
# 29 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 30 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp" 2

namespace boost { namespace python {

namespace detail
{


  struct overloads_base
  {
      overloads_base(char const* doc_)
          : m_doc(doc_) {}

      overloads_base(char const* doc_, detail::keyword_range const& kw)
          : m_doc(doc_), m_keywords(kw) {}

      char const* doc_string() const
      {
          return m_doc;
      }

      detail::keyword_range const& keywords() const
      {
          return m_keywords;
      }

   private:
      char const* m_doc;
      detail::keyword_range m_keywords;
  };



  template <class CallPoliciesT, class OverloadsT>
  struct overloads_proxy
      : public overloads_base
  {
      typedef typename OverloadsT::non_void_return_type non_void_return_type;
      typedef typename OverloadsT::void_return_type void_return_type;

      overloads_proxy(
          CallPoliciesT const& policies_
          , char const* doc
          , keyword_range const& kw
          )
          : overloads_base(doc, kw)
            , policies(policies_)
      {}

      CallPoliciesT
      call_policies() const
      {
          return policies;
      }

      CallPoliciesT policies;
  };





  template <class DerivedT>
  struct overloads_common
      : public overloads_base
  {
      overloads_common(char const* doc)
          : overloads_base(doc) {}

      overloads_common(char const* doc, keyword_range const& kw)
          : overloads_base(doc, kw) {}

      default_call_policies
      call_policies() const
      {
          return default_call_policies();
      }

      template <class CallPoliciesT>
      overloads_proxy<CallPoliciesT, DerivedT>
      operator[](CallPoliciesT const& policies) const
      {
          return overloads_proxy<CallPoliciesT, DerivedT>(
              policies, this->doc_string(), this->keywords());
      }
  };

}}}
# 15 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits.hpp" 1
# 22 "/usr/include/boost-1_42/boost/type_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_destructor.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_destructor.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_destructor.hpp" 2

namespace boost {

template< typename T > struct has_nothrow_destructor : ::boost::integral_constant<bool,::boost::has_trivial_destructor<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 24 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_destructor.hpp" 2
# 23 "/usr/include/boost-1_42/boost/type_traits.hpp" 2




# 1 "/usr/include/boost-1_42/boost/type_traits/has_virtual_destructor.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/has_virtual_destructor.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/usr/include/boost-1_42/boost/type_traits/has_virtual_destructor.hpp" 2

namespace boost {

template< typename T > struct has_virtual_destructor : ::boost::integral_constant<bool,__has_virtual_destructor(T)> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 24 "/usr/include/boost-1_42/boost/type_traits/has_virtual_destructor.hpp" 2
# 28 "/usr/include/boost-1_42/boost/type_traits.hpp" 2






# 1 "/usr/include/boost-1_42/boost/type_traits/is_base_of.hpp" 1
# 19 "/usr/include/boost-1_42/boost/type_traits/is_base_of.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 20 "/usr/include/boost-1_42/boost/type_traits/is_base_of.hpp" 2

namespace boost {

   namespace detail{
      template <class B, class D>
      struct is_base_of_imp
      {
          typedef typename remove_cv<B>::type ncvB;
          typedef typename remove_cv<D>::type ncvD;
          static const bool value = (::boost::type_traits::ice_or< (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value), (::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value)

                                                                                                                                 ;
      };
   }

template< typename Base, typename Derived > struct is_base_of : ::boost::integral_constant<bool,(::boost::detail::is_base_of_imp<Base, Derived>::value)> { };






template< typename Base, typename Derived > struct is_base_of< Base&,Derived > : ::boost::integral_constant<bool,false> { };
template< typename Base, typename Derived > struct is_base_of< Base,Derived& > : ::boost::integral_constant<bool,false> { };
template< typename Base, typename Derived > struct is_base_of< Base&,Derived& > : ::boost::integral_constant<bool,false> { };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 50 "/usr/include/boost-1_42/boost/type_traits/is_base_of.hpp" 2
# 35 "/usr/include/boost-1_42/boost/type_traits.hpp" 2







# 1 "/usr/include/boost-1_42/boost/type_traits/is_floating_point.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/is_floating_point.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 14 "/usr/include/boost-1_42/boost/type_traits/is_floating_point.hpp" 2

namespace boost {


template< typename T > struct is_floating_point : ::boost::integral_constant<bool,false> { };
template<> struct is_floating_point< float > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_floating_point< double > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_floating_point< long double > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double const volatile > : ::boost::integral_constant<bool,true> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 26 "/usr/include/boost-1_42/boost/type_traits/is_floating_point.hpp" 2
# 43 "/usr/include/boost-1_42/boost/type_traits.hpp" 2




# 1 "/usr/include/boost-1_42/boost/type_traits/is_member_object_pointer.hpp" 1
# 20 "/usr/include/boost-1_42/boost/type_traits/is_member_object_pointer.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 21 "/usr/include/boost-1_42/boost/type_traits/is_member_object_pointer.hpp" 2

namespace boost {

namespace detail{

template <typename T>
struct is_member_object_pointer_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::is_member_pointer<T>::value, ::boost::type_traits::ice_not< ::boost::is_member_function_pointer<T>::value >::value >::value )





                 ;
};

}

template< typename T > struct is_member_object_pointer : ::boost::integral_constant<bool,::boost::detail::is_member_object_pointer_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 45 "/usr/include/boost-1_42/boost/type_traits/is_member_object_pointer.hpp" 2
# 48 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
# 60 "/usr/include/boost-1_42/boost/type_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/rank.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/rank.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2
# 15 "/usr/include/boost-1_42/boost/type_traits/rank.hpp" 2

namespace boost {



namespace detail{

template <class T, std::size_t N>
struct rank_imp
{
   static const std::size_t value = N;
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T const[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T volatile[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T const volatile[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};


template <class T, std::size_t N>
struct rank_imp<T[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};
template <class T, std::size_t N>
struct rank_imp<T const[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};
template <class T, std::size_t N>
struct rank_imp<T volatile[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};
template <class T, std::size_t N>
struct rank_imp<T const volatile[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};


}






template< typename T > struct rank : ::boost::integral_constant<std::size_t,(::boost::detail::rank_imp<T,0>::value)> { };


}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_undef.hpp" 1
# 88 "/usr/include/boost-1_42/boost/type_traits/rank.hpp" 2
# 61 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/extent.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/extent.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2
# 15 "/usr/include/boost-1_42/boost/type_traits/extent.hpp" 2

namespace boost {

namespace detail{
# 29 "/usr/include/boost-1_42/boost/type_traits/extent.hpp"
template <class T, std::size_t N>
struct extent_imp
{
   static const std::size_t value = 0;
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T const[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T volatile[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T const volatile[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R>
struct extent_imp<T[R],0>
{
   static const std::size_t value = R;
};

template <class T, std::size_t R>
struct extent_imp<T const[R], 0>
{
   static const std::size_t value = R;
};

template <class T, std::size_t R>
struct extent_imp<T volatile[R], 0>
{
   static const std::size_t value = R;
};

template <class T, std::size_t R>
struct extent_imp<T const volatile[R], 0>
{
   static const std::size_t value = R;
};


template <class T, std::size_t N>
struct extent_imp<T[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T, std::size_t N>
struct extent_imp<T const[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T, std::size_t N>
struct extent_imp<T volatile[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T, std::size_t N>
struct extent_imp<T const volatile[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T>
struct extent_imp<T[], 0>
{
   static const std::size_t value = 0;
};
template <class T>
struct extent_imp<T const[], 0>
{
   static const std::size_t value = 0;
};
template <class T>
struct extent_imp<T volatile[], 0>
{
   static const std::size_t value = 0;
};
template <class T>
struct extent_imp<T const volatile[], 0>
{
   static const std::size_t value = 0;
};




}

template <class T, std::size_t N = 0>
struct extent
   : public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
{




   
};

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_undef.hpp" 1
# 144 "/usr/include/boost-1_42/boost/type_traits/extent.hpp" 2
# 62 "/usr/include/boost-1_42/boost/type_traits.hpp" 2

# 1 "/usr/include/boost-1_42/boost/type_traits/remove_extent.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/remove_extent.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 15 "/usr/include/boost-1_42/boost/type_traits/remove_extent.hpp" 2






# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/remove_extent.hpp" 2



namespace boost {

template< typename T > struct remove_extent { typedef T type; };


template< typename T, std::size_t N > struct remove_extent<T[N]> { typedef T type; };
template< typename T, std::size_t N > struct remove_extent<T const[N]> { typedef T const type; };
template< typename T, std::size_t N > struct remove_extent<T volatile[N]> { typedef T volatile type; };
template< typename T, std::size_t N > struct remove_extent<T const volatile[N]> { typedef T const volatile type; };

template< typename T > struct remove_extent<T[]> { typedef T type; };
template< typename T > struct remove_extent<T const[]> { typedef T const type; };
template< typename T > struct remove_extent<T volatile[]> { typedef T volatile type; };
template< typename T > struct remove_extent<T const volatile[]> { typedef T const volatile type; };



}



# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 47 "/usr/include/boost-1_42/boost/type_traits/remove_extent.hpp" 2
# 64 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/remove_all_extents.hpp" 1
# 13 "/usr/include/boost-1_42/boost/type_traits/remove_all_extents.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 14 "/usr/include/boost-1_42/boost/type_traits/remove_all_extents.hpp" 2







# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/remove_all_extents.hpp" 2



namespace boost {

template< typename T > struct remove_all_extents { typedef T type; };


template< typename T, std::size_t N > struct remove_all_extents<T[N]> { typedef typename boost::remove_all_extents<T>::type type; };
template< typename T, std::size_t N > struct remove_all_extents<T const[N]> { typedef typename boost::remove_all_extents<T const>::type type; };
template< typename T, std::size_t N > struct remove_all_extents<T volatile[N]> { typedef typename boost::remove_all_extents<T volatile>::type type; };
template< typename T, std::size_t N > struct remove_all_extents<T const volatile[N]> { typedef typename boost::remove_all_extents<T const volatile>::type type; };

template< typename T > struct remove_all_extents<T[]> { typedef typename boost::remove_all_extents<T>::type type; };
template< typename T > struct remove_all_extents<T const[]> { typedef typename boost::remove_all_extents<T const>::type type; };
template< typename T > struct remove_all_extents<T volatile[]> { typedef typename boost::remove_all_extents<T volatile>::type type; };
template< typename T > struct remove_all_extents<T const volatile[]> { typedef typename boost::remove_all_extents<T const volatile>::type type; };



}



# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 47 "/usr/include/boost-1_42/boost/type_traits/remove_all_extents.hpp" 2
# 65 "/usr/include/boost-1_42/boost/type_traits.hpp" 2







# 1 "/usr/include/boost-1_42/boost/type_traits/aligned_storage.hpp" 1
# 73 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/floating_point_promotion.hpp" 1
# 21 "/usr/include/boost-1_42/boost/type_traits/floating_point_promotion.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/usr/include/boost-1_42/boost/type_traits/floating_point_promotion.hpp" 2

namespace boost {

namespace type_traits { namespace detail {



template<class T>
struct floating_point_promotion
{
    typedef T type;
};

template<>
struct floating_point_promotion<float>
{
    typedef double type;
};

template<>
struct floating_point_promotion<float const>
{
    typedef double const type;
};

template<>
struct floating_point_promotion<float volatile>
{
    typedef double volatile type;
};

template<>
struct floating_point_promotion<float const volatile>
{
    typedef double const volatile type;
};
# 78 "/usr/include/boost-1_42/boost/type_traits/floating_point_promotion.hpp"
} }

template< typename T > struct floating_point_promotion { typedef typename boost::type_traits::detail::floating_point_promotion<T>::type type; };





}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 89 "/usr/include/boost-1_42/boost/type_traits/floating_point_promotion.hpp" 2
# 74 "/usr/include/boost-1_42/boost/type_traits.hpp" 2

# 1 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp" 1
# 20 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 21 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp" 2

namespace boost {

namespace type_traits { namespace detail {


template <class T> struct need_promotion : boost::is_enum<T> {};


template<> struct need_promotion<char > : true_type {};
template<> struct need_promotion<signed char > : true_type {};
template<> struct need_promotion<unsigned char > : true_type {};
template<> struct need_promotion<signed short int > : true_type {};
template<> struct need_promotion<unsigned short int> : true_type {};
# 63 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
template<> struct need_promotion<boost::ulong_long_type> : integral_constant<bool, (sizeof(boost::ulong_long_type) < sizeof(int))> {};
template<> struct need_promotion<boost::long_long_type> : integral_constant<bool, (sizeof(boost::long_long_type) < sizeof(int))> {};
# 75 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
template<> struct need_promotion<wchar_t> : true_type {};





template<> struct need_promotion<bool> : true_type {};




template<int Index, int IsConst, int IsVolatile> struct promote_from_index;
# 95 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
template<> struct promote_from_index<1,0,0> { typedef int type; }; template<> struct promote_from_index<1,0,1> { typedef int volatile type; }; template<> struct promote_from_index<1,1,0> { typedef int const type; }; template<> struct promote_from_index<1,1,1> { typedef int const volatile type; };
template<> struct promote_from_index<2,0,0> { typedef unsigned int type; }; template<> struct promote_from_index<2,0,1> { typedef unsigned int volatile type; }; template<> struct promote_from_index<2,1,0> { typedef unsigned int const type; }; template<> struct promote_from_index<2,1,1> { typedef unsigned int const volatile type; };
template<> struct promote_from_index<3,0,0> { typedef long type; }; template<> struct promote_from_index<3,0,1> { typedef long volatile type; }; template<> struct promote_from_index<3,1,0> { typedef long const type; }; template<> struct promote_from_index<3,1,1> { typedef long const volatile type; };
template<> struct promote_from_index<4,0,0> { typedef unsigned long type; }; template<> struct promote_from_index<4,0,1> { typedef unsigned long volatile type; }; template<> struct promote_from_index<4,1,0> { typedef unsigned long const type; }; template<> struct promote_from_index<4,1,1> { typedef unsigned long const volatile type; };
# 107 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
template<> struct promote_from_index<5,0,0> { typedef boost::long_long_type type; }; template<> struct promote_from_index<5,0,1> { typedef boost::long_long_type volatile type; }; template<> struct promote_from_index<5,1,0> { typedef boost::long_long_type const type; }; template<> struct promote_from_index<5,1,1> { typedef boost::long_long_type const volatile type; };
template<> struct promote_from_index<6,0,0> { typedef boost::ulong_long_type type; }; template<> struct promote_from_index<6,0,1> { typedef boost::ulong_long_type volatile type; }; template<> struct promote_from_index<6,1,0> { typedef boost::ulong_long_type const type; }; template<> struct promote_from_index<6,1,1> { typedef boost::ulong_long_type const volatile type; };
# 120 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
template<int N>
struct sized_type_for_promotion
{
    typedef char (&type)[N];
};
# 136 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
sized_type_for_promotion<1>::type promoted_index_tester(int);
sized_type_for_promotion<2>::type promoted_index_tester(unsigned int);
sized_type_for_promotion<3>::type promoted_index_tester(long);
sized_type_for_promotion<4>::type promoted_index_tester(unsigned long);


sized_type_for_promotion<5>::type promoted_index_tester(boost::long_long_type);
sized_type_for_promotion<6>::type promoted_index_tester(boost::ulong_long_type);
# 154 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
template<class T>
struct promoted_index
{
    static T testee;
    static const int value = sizeof(promoted_index_tester(+testee));

};

template<class T>
struct integral_promotion_impl
{
    typedef typename promote_from_index<
        (boost::type_traits::detail::promoted_index<T>::value)
      , (boost::is_const<T>::value)
      , (boost::is_volatile<T>::value)
      >::type type;
};

template<class T>
struct integral_promotion
  : boost::mpl::eval_if<
        need_promotion<typename remove_cv<T>::type>
      , integral_promotion_impl<T>
      , boost::mpl::identity<T>
      >
{
};

} }

template< typename T > struct integral_promotion { typedef typename boost::type_traits::detail::integral_promotion<T>::type type; };





}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 193 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp" 2
# 76 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/promote.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/promote.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 15 "/usr/include/boost-1_42/boost/type_traits/promote.hpp" 2

namespace boost {

namespace detail {

template<class T>
struct promote_impl
  : integral_promotion<
        typename floating_point_promotion<T>::type
      >
{
};

}

template< typename T > struct promote { typedef typename boost::detail::promote_impl<T>::type type; };




}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 38 "/usr/include/boost-1_42/boost/type_traits/promote.hpp" 2
# 77 "/usr/include/boost-1_42/boost/type_traits.hpp" 2


# 1 "/usr/include/boost-1_42/boost/type_traits/make_signed.hpp" 1
# 29 "/usr/include/boost-1_42/boost/type_traits/make_signed.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
# 30 "/usr/include/boost-1_42/boost/type_traits/make_signed.hpp" 2

namespace boost {

namespace detail {

template <class T>
struct make_signed_imp
{
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)>
 boost_static_assert_typedef_39;

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)>

 boost_static_assert_typedef_43;


   typedef typename remove_cv<T>::type t_no_cv;
   typedef typename mpl::if_c<
      (::boost::type_traits::ice_and<
         ::boost::is_signed<T>::value,
         ::boost::is_integral<T>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
      T,
      typename mpl::if_c<
         (::boost::type_traits::ice_and<
            ::boost::is_integral<T>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
         ::value),
         typename mpl::if_<
            is_same<t_no_cv, unsigned char>,
            signed char,
            typename mpl::if_<
               is_same<t_no_cv, unsigned short>,
               signed short,
               typename mpl::if_<
                  is_same<t_no_cv, unsigned int>,
                  int,
                  typename mpl::if_<
                     is_same<t_no_cv, unsigned long>,
                     long,

                     boost::long_long_type





                  >::type
               >::type
            >::type
         >::type,

         typename mpl::if_c<
            sizeof(t_no_cv) == sizeof(unsigned char),
            signed char,
            typename mpl::if_c<
               sizeof(t_no_cv) == sizeof(unsigned short),
               signed short,
               typename mpl::if_c<
                  sizeof(t_no_cv) == sizeof(unsigned int),
                  int,
                  typename mpl::if_c<
                     sizeof(t_no_cv) == sizeof(unsigned long),
                     long,

                     boost::long_long_type





                  >::type
               >::type
            >::type
         >::type
      >::type
   >::type base_integer_type;


   typedef typename mpl::if_<
      is_const<T>,
      typename add_const<base_integer_type>::type,
      base_integer_type
   >::type const_base_integer_type;


   typedef typename mpl::if_<
      is_volatile<T>,
      typename add_volatile<const_base_integer_type>::type,
      const_base_integer_type
   >::type type;
};


}

template< typename T > struct make_signed { typedef typename boost::detail::make_signed_imp<T>::type type; };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
# 135 "/usr/include/boost-1_42/boost/type_traits/make_signed.hpp" 2
# 80 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/decay.hpp" 1
# 21 "/usr/include/boost-1_42/boost/type_traits/decay.hpp"
namespace boost
{

    template< class T >
    struct decay
    {
    private:
        typedef typename remove_reference<T>::type Ty;
    public:
        typedef typename mpl::eval_if<
            is_array<Ty>,
            mpl::identity<typename remove_bounds<Ty>::type*>,
            typename mpl::eval_if<
                is_function<Ty>,
                add_pointer<Ty>,
                mpl::identity<Ty>
            >
        >::type type;
    };

}
# 81 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/type_traits/is_complex.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/is_complex.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
# 15 "/usr/include/boost-1_42/boost/type_traits/is_complex.hpp" 2


namespace boost {
namespace detail{

struct is_convertible_from_tester
{
   template <class T>
   is_convertible_from_tester(const std::complex<T>&);
};

}

template< typename T > struct is_complex : ::boost::integral_constant<bool,(::boost::is_convertible<T, detail::is_convertible_from_tester>::value)> { };

}

# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 33 "/usr/include/boost-1_42/boost/type_traits/is_complex.hpp" 2
# 82 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
# 16 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 2
# 28 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
namespace boost { namespace python {

struct module;

namespace objects
{
  struct class_base;
}

namespace detail
{







  template <class Func, class CallPolicies, class NameSpaceT>
  static void name_space_def(
      NameSpaceT& name_space
      , char const* name
      , Func f
      , keyword_range const& kw
      , CallPolicies const& policies
      , char const* doc
      , objects::class_base*
      )
  {
      typedef typename NameSpaceT::wrapped_type wrapped_type;

      objects::add_to_namespace(
          name_space, name,
          detail::make_keyword_range_function(
              f, policies, kw, get_signature(f, (wrapped_type*)0))
        , doc
      );
  }

  template <class Func, class CallPolicies>
  static void name_space_def(
      object& name_space
      , char const* name
      , Func f
      , keyword_range const& kw
      , CallPolicies const& policies
      , char const* doc
      , ...
      )
  {
      scope within(name_space);

      detail::scope_setattr_doc(
          name
          , detail::make_keyword_range_function(f, policies, kw)
          , doc);
  }


  template <class Func, class CallPolicies, class NameSpaceT>
  static void name_space_def(
      NameSpaceT& name_space
      , char const* name
      , Func f
      , keyword_range const& kw
      , CallPolicies const& policies
      , char const* doc
      , module*
      )
  {
      name_space.def(name, f, policies, doc);
  }
# 125 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
  template <int N>
  struct define_stub_function {};




# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<0> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_0
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<1> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_1
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<2> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_2
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<3> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_3
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<4> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_4
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<5> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_5
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<6> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_6
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<7> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_7
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<8> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_8
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<9> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_9
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<10> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_10
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<11> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_11
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<12> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_12
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<13> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_13
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<14> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_14
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
template <>
struct define_stub_function<15> {
    template <class StubsT, class CallPolicies, class NameSpaceT>
    static void define(
        char const* name
        , StubsT const&
        , keyword_range const& kw
        , CallPolicies const& policies
        , NameSpaceT& name_space
        , char const* doc)
    {
        detail::name_space_def(
            name_space
            , name
            , &StubsT::func_15
            , kw
            , policies
            , doc
            , &name_space);
    }
};
# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 132 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 2
# 157 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
  template <int N>
  struct define_with_defaults_helper {

      template <class StubsT, class CallPolicies, class NameSpaceT>
      static void
      def(
          char const* name,
          StubsT stubs,
          keyword_range kw,
          CallPolicies const& policies,
          NameSpaceT& name_space,
          char const* doc)
      {

          define_stub_function<N>::define(name, stubs, kw, policies, name_space, doc);

          if (kw.second > kw.first)
              --kw.second;


          define_with_defaults_helper<N-1>::def(name, stubs, kw, policies, name_space, doc);
      }
  };

  template <>
  struct define_with_defaults_helper<0> {

      template <class StubsT, class CallPolicies, class NameSpaceT>
      static void
      def(
          char const* name,
          StubsT stubs,
          keyword_range const& kw,
          CallPolicies const& policies,
          NameSpaceT& name_space,
          char const* doc)
      {

          define_stub_function<0>::define(name, stubs, kw, policies, name_space, doc);

      }
  };
# 228 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
  template <class OverloadsT, class NameSpaceT, class SigT>
  inline void
  define_with_defaults(
      char const* name,
      OverloadsT const& overloads,
      NameSpaceT& name_space,
      SigT const&)
  {
      typedef typename mpl::front<SigT>::type return_type;
      typedef typename OverloadsT::void_return_type void_return_type;
      typedef typename OverloadsT::non_void_return_type non_void_return_type;

      typedef typename mpl::if_c<
          boost::is_same<void, return_type>::value
          , void_return_type
          , non_void_return_type
      >::type stubs_type;

      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((stubs_type::max_args) <= mpl::size<SigT>::value) == 0 ? false : true) >)>
 boost_static_assert_typedef_247;

      typedef typename stubs_type::template gen<SigT> gen_type;
      define_with_defaults_helper<stubs_type::n_funcs-1>::def(
          name
          , gen_type()
          , overloads.keywords()
          , overloads.call_policies()
          , name_space
          , overloads.doc_string());
  }

}

}}
# 12 "/usr/include/boost-1_42/boost/python/overloads.hpp" 2
# 53 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/pure_virtual.hpp" 1
# 13 "/usr/include/boost-1_42/boost/python/pure_virtual.hpp"
# 1 "/usr/include/boost-1_42/boost/python/detail/nullary_function_adaptor.hpp" 1
# 14 "/usr/include/boost-1_42/boost/python/detail/nullary_function_adaptor.hpp"
namespace boost { namespace python { namespace detail {




template <class NullaryFunction>
struct nullary_function_adaptor
{
    nullary_function_adaptor(NullaryFunction fn)
      : m_fn(fn)
    {}

    void operator()() const { m_fn(); }
# 38 "/usr/include/boost-1_42/boost/python/detail/nullary_function_adaptor.hpp"
# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
# 37 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
        template < class A0> void operator()( A0 const& ) const { m_fn(); }


        template < class A0 , class A1> void operator()( A0 const& , A1 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2> void operator()( A0 const& , A1 const& , A2 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3> void operator()( A0 const& , A1 const& , A2 const& , A3 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& ) const { m_fn(); }


        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& ) const { m_fn(); }
# 39 "/usr/include/boost-1_42/boost/python/detail/nullary_function_adaptor.hpp" 2

 private:
    NullaryFunction m_fn;
};

}}}
# 14 "/usr/include/boost-1_42/boost/python/pure_virtual.hpp" 2

namespace boost { namespace python {

namespace detail
{






  void pure_virtual_called();


  template <class S, class T1, class T2>
  struct replace_front2
  {

      typedef typename mpl::push_front<
          typename mpl::push_front<
              typename mpl::pop_front<
                  typename mpl::pop_front<
                      S
                  >::type
              >::type
            , T2
          >::type
        , T1
      >::type type;
  };




  template <class C, class S>
  typename replace_front2<S,void,C&>::type
  error_signature(S )
  {
      typedef typename replace_front2<S,void,C&>::type r;
      return r();
  }
# 65 "/usr/include/boost-1_42/boost/python/pure_virtual.hpp"
  template <class PointerToMemberFunction>
  struct pure_virtual_visitor
    : def_visitor<pure_virtual_visitor<PointerToMemberFunction> >
  {
      pure_virtual_visitor(PointerToMemberFunction pmf)
        : m_pmf(pmf)
      {}

   private:
      friend class python::def_visitor_access;

      template <class C_, class Options>
      void visit(C_& c, char const* name, Options& options) const
      {

          typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!Options::has_default_implementation) == 0 ? false : true) >)> boost_static_assert_typedef_80;


          c.def(
              name
            , m_pmf
            , options.doc()
            , options.keywords()
            , options.policies()
          );

          typedef typename C_::metadata::held_type held_type;


          c.def(
              name
            , make_function(
                  detail::nullary_function_adaptor<void(*)()>(pure_virtual_called)
                , default_call_policies()
                , detail::error_signature<held_type>(detail::get_signature(m_pmf))
              )
          );
      }

   private:
      PointerToMemberFunction m_pmf;
  };
}







template <class PointerToMemberFunction>
detail::pure_virtual_visitor<PointerToMemberFunction>
pure_virtual(PointerToMemberFunction pmf)
{
    return detail::pure_virtual_visitor<PointerToMemberFunction>(pmf);
}

}}
# 55 "/usr/include/boost-1_42/boost/python.hpp" 2


# 1 "/usr/include/boost-1_42/boost/python/register_ptr_to_python.hpp" 1
# 12 "/usr/include/boost-1_42/boost/python/register_ptr_to_python.hpp"
namespace boost { namespace python {

template <class P>
void register_ptr_to_python()
{
    typedef typename boost::python::pointee<P>::type X;
    objects::class_value_wrapper<
        P
      , objects::make_ptr_instance<
            X
          , objects::pointer_holder<P,X>
        >
    >();
}

}}
# 58 "/usr/include/boost-1_42/boost/python.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/return_arg.hpp" 1
# 24 "/usr/include/boost-1_42/boost/python/return_arg.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 25 "/usr/include/boost-1_42/boost/python/return_arg.hpp" 2

namespace boost { namespace python {

namespace detail
{
  template <std::size_t>
  struct return_arg_pos_argument_must_be_positive

  {}

  ;

  struct return_none
  {
      template <class T> struct apply
      {
          struct type
          {
              static bool convertible()
              {
                  return true;
              }

              PyObject *operator()( typename value_arg<T>::type ) const
              {
                  return none();
              }

              PyTypeObject const *get_pytype() const { return converter::expected_pytype_for_arg<T>::get_pytype() ; }

          };
      };
  };
}

template <
    std::size_t arg_pos=1
  , class Base = default_call_policies
>
struct return_arg : Base
{
 private:
    static const bool legal = arg_pos > 0;

 public:
    typedef typename mpl::if_c<
        legal
        , detail::return_none
        , detail::return_arg_pos_argument_must_be_positive<arg_pos>




    >::type result_converter;

    template <class ArgumentPackage>
    static PyObject* postcall(ArgumentPackage const& args, PyObject* result)
    {


        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((arg_pos > 0) == 0 ? false : true) >)> boost_static_assert_typedef_85;

        result = Base::postcall(args,result);
        if (!result)
            return 0;
        if ( --((PyObject*)(result))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(result)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(result))));
        return incref( detail::get(mpl::int_<arg_pos-1>(),args) );
    }

    template <class Sig>
    struct extract_return_type : mpl::at_c<Sig, arg_pos>
    {
    };

};

template <
    class Base = default_call_policies
    >
struct return_self
  : return_arg<1,Base>
{};

}}
# 59 "/usr/include/boost-1_42/boost/python.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/return_opaque_pointer.hpp" 1
# 18 "/usr/include/boost-1_42/boost/python/return_opaque_pointer.hpp"
namespace boost { namespace python {

namespace detail
{
  template <class Pointee>
  static void opaque_pointee(Pointee const volatile*)
  {
      force_instantiate(opaque<Pointee>::instance);
  }
}

struct return_opaque_pointer
{
    template <class R>
    struct apply
    {
        struct RETURN_OPAQUE_POINTER_EXPECTS_A_POINTER_TYPE; typedef struct RETURN_OPAQUE_POINTER_EXPECTS_A_POINTER_TYPE34 : boost::mpl::assert_ { static boost::mpl::failed ************ (RETURN_OPAQUE_POINTER_EXPECTS_A_POINTER_TYPE::************ assert_arg()) (R) { return 0; } } mpl_assert_arg34; enum { mpl_assertion_in_line_34 = sizeof( boost::mpl::assertion_failed<(is_pointer<R>::value)>( mpl_assert_arg34::assert_arg() ) ) };

        struct type :
          boost::python::to_python_value<
              typename detail::value_arg<R>::type
          >
        {
            type() { detail::opaque_pointee(R()); }
        };
    };
};

}}
# 61 "/usr/include/boost-1_42/boost/python.hpp" 2
# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/raw_function.hpp" 1
# 16 "/usr/include/boost-1_42/boost/python/raw_function.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 17 "/usr/include/boost-1_42/boost/python/raw_function.hpp" 2

namespace boost { namespace python {

namespace detail
{
  template <class F>
  struct raw_dispatcher
  {
      raw_dispatcher(F f) : f(f) {}

      PyObject* operator()(PyObject* args, PyObject* keywords)
      {
          return incref(
              object(
                  f(
                      tuple(borrowed_reference(args))
                    , keywords ? dict(borrowed_reference(keywords)) : dict()
                  )
              ).ptr()
          );
      }

   private:
      F f;
  };

  object make_raw_function(objects::py_function);
}

template <class F>
object raw_function(F f, std::size_t min_args = 0)
{
    return detail::make_raw_function(
        objects::py_function(
            detail::raw_dispatcher<F>(f)
          , mpl::vector1<PyObject*>()
          , min_args
          , (std::numeric_limits<unsigned>::max)()
        )
    );
}

}}
# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/slice.hpp" 1
# 15 "/usr/include/boost-1_42/boost/python/slice.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator/iterator_traits.hpp" 1
# 11 "/usr/include/boost-1_42/boost/iterator/iterator_traits.hpp"
namespace boost {
# 27 "/usr/include/boost-1_42/boost/iterator/iterator_traits.hpp"
template <class Iterator>
struct iterator_value
{
    typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
};

template <class Iterator>
struct iterator_reference
{
    typedef typename boost::detail::iterator_traits<Iterator>::reference type;
};


template <class Iterator>
struct iterator_pointer
{
    typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
};

template <class Iterator>
struct iterator_difference
{
    typedef typename boost::detail::iterator_traits<Iterator>::difference_type type;
};

template <class Iterator>
struct iterator_category
{
    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
};
# 90 "/usr/include/boost-1_42/boost/iterator/iterator_traits.hpp"
}
# 16 "/usr/include/boost-1_42/boost/python/slice.hpp" 2




namespace boost { namespace python {

namespace detail
{
  class slice_base : public object
  {
   public:







      object start() const;
      object stop() const;
      object step() const;

   protected:
      explicit slice_base(PyObject*, PyObject*, PyObject*);

      inline explicit slice_base(python::detail::borrowed_reference p) : object(p) {} inline explicit slice_base(python::detail::new_reference p) : object(p) {} inline explicit slice_base(python::detail::new_non_null_reference p) : object(p) {}
  };
}

class slice : public detail::slice_base
{
    typedef detail::slice_base base;
 public:

    slice() : base(0,0,0) {}



    template<typename Integer1, typename Integer2>
    slice( Integer1 start, Integer2 stop)
        : base( object(start).ptr(), object(stop).ptr(), 0 )
    {}

    template<typename Integer1, typename Integer2, typename Integer3>
    slice( Integer1 start, Integer2 stop, Integer3 stride)
        : base( object(start).ptr(), object(stop).ptr(), object(stride).ptr() )
    {}
# 103 "/usr/include/boost-1_42/boost/python/slice.hpp"
    template<typename RandomAccessIterator>
    struct range
    {
        RandomAccessIterator start;
        RandomAccessIterator stop;
        typename iterator_difference<RandomAccessIterator>::type step;
    };

    template<typename RandomAccessIterator>
    slice::range<RandomAccessIterator>
    get_indicies( const RandomAccessIterator& begin,
        const RandomAccessIterator& end) const
    {



        slice::range<RandomAccessIterator> ret;

        typedef typename iterator_difference<RandomAccessIterator>::type difference_type;
        difference_type max_dist = boost::detail::distance(begin, end);

        object slice_start = this->start();
        object slice_stop = this->stop();
        object slice_step = this->step();


        if (slice_step == object()) {
            ret.step = 1;
        }
        else {
            ret.step = extract<long>( slice_step);
            if (ret.step == 0) {
                PyErr_SetString( PyExc_IndexError, "step size cannot be zero.");
                throw_error_already_set();
            }
        }


        if (slice_start == object()) {
            if (ret.step < 0) {
                ret.start = end;
                --ret.start;
            }
            else
                ret.start = begin;
        }
        else {
            difference_type i = extract<long>( slice_start);
            if (i >= max_dist && ret.step > 0)
                    throw std::invalid_argument( "Zero-length slice");
            if (i >= 0) {
                ret.start = begin;
                using std::min;
                std::advance( ret.start, min (i, max_dist-1));
            }
            else {
                if (i < -max_dist && ret.step < 0)
                    throw std::invalid_argument( "Zero-length slice");
                ret.start = end;

                std::advance( ret.start, (-i < max_dist) ? i : -max_dist );
            }
        }



        if (slice_stop == object()) {
            if (ret.step < 0) {
                ret.stop = begin;
            }
            else {
                ret.stop = end;
                std::advance( ret.stop, -1);
            }
        }
        else {
            difference_type i = extract<long>(slice_stop);

            if (ret.step < 0) {
                if (i+1 >= max_dist || i == -1)
                    throw std::invalid_argument( "Zero-length slice");

                if (i >= 0) {
                    ret.stop = begin;
                    std::advance( ret.stop, i+1);
                }
                else {
                    ret.stop = end;
                    std::advance( ret.stop, (-i < max_dist) ? i : -max_dist);
                }
            }
            else {
                if (i == 0 || -i >= max_dist)
                    throw std::invalid_argument( "Zero-length slice");

                if (i > 0) {
                    ret.stop = begin;
                    std::advance( ret.stop, (std::min)( i-1, max_dist-1));
                }
                else {
                    ret.stop = end;
                    std::advance( ret.stop, i-1);
                }
            }
        }






        typename iterator_difference<RandomAccessIterator>::type final_dist =
            boost::detail::distance( ret.start, ret.stop);



        if (final_dist == 0)
            return ret;




        if ((final_dist > 0) != (ret.step > 0))
            throw std::invalid_argument( "Zero-length slice.");





        if (final_dist < 0) {
            difference_type remainder = -final_dist % -ret.step;
            std::advance( ret.stop, remainder);
        }
        else {
            difference_type remainder = final_dist % ret.step;
            std::advance( ret.stop, -remainder);
        }

        return ret;
    }

 public:




    inline explicit slice(python::detail::borrowed_reference p) : detail::slice_base(p) {} inline explicit slice(python::detail::new_reference p) : detail::slice_base(p) {} inline explicit slice(python::detail::new_non_null_reference p) : detail::slice_base(p) {}
};


namespace converter {

template<>
struct object_manager_traits<slice>
    : pytype_object_manager_traits<&PySlice_Type, slice>
{
};

}

} }
# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 2

# 1 "/usr/include/boost-1_42/boost/python/suite/indexing/indexing_suite.hpp" 1
# 12 "/usr/include/boost-1_42/boost/python/suite/indexing/indexing_suite.hpp"
# 1 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp"
# 1 "/usr/include/boost-1_42/boost/scoped_ptr.hpp" 1
# 14 "/usr/include/boost-1_42/boost/scoped_ptr.hpp"
# 1 "/usr/include/boost-1_42/boost/smart_ptr/scoped_ptr.hpp" 1
# 14 "/usr/include/boost-1_42/boost/smart_ptr/scoped_ptr.hpp"
# 1 "/usr/include/boost-1_42/boost/assert.hpp" 1
# 36 "/usr/include/boost-1_42/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 37 "/usr/include/boost-1_42/boost/assert.hpp" 2
# 15 "/usr/include/boost-1_42/boost/smart_ptr/scoped_ptr.hpp" 2







namespace boost
{
# 39 "/usr/include/boost-1_42/boost/smart_ptr/scoped_ptr.hpp"
template<class T> class scoped_ptr
{
private:

    T * px;

    scoped_ptr(scoped_ptr const &);
    scoped_ptr & operator=(scoped_ptr const &);

    typedef scoped_ptr<T> this_type;

    void operator==( scoped_ptr const& ) const;
    void operator!=( scoped_ptr const& ) const;

public:

    typedef T element_type;

    explicit scoped_ptr( T * p = 0 ): px( p )
    {



    }



    explicit scoped_ptr( std::auto_ptr<T> p ): px( p.release() )
    {



    }



    ~scoped_ptr()
    {



        boost::checked_delete( px );
    }

    void reset(T * p = 0)
    {
        (static_cast<void> (0));
        this_type(p).swap(*this);
    }

    T & operator*() const
    {
        (static_cast<void> (0));
        return *px;
    }

    T * operator->() const
    {
        (static_cast<void> (0));
        return px;
    }

    T * get() const
    {
        return px;
    }


# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/operator_bool.hpp" 1
# 43 "/usr/include/boost-1_42/boost/smart_ptr/detail/operator_bool.hpp"
    typedef T * this_type::*unspecified_bool_type;

    operator unspecified_bool_type() const
    {
        return px == 0? 0: &this_type::px;
    }




    bool operator! () const
    {
        return px == 0;
    }
# 108 "/usr/include/boost-1_42/boost/smart_ptr/scoped_ptr.hpp" 2

    void swap(scoped_ptr & b)
    {
        T * tmp = b.px;
        b.px = px;
        px = tmp;
    }
};

template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b)
{
    a.swap(b);
}



template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
{
    return p.get();
}

}
# 15 "/usr/include/boost-1_42/boost/scoped_ptr.hpp" 2
# 11 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 2

# 1 "/usr/include/boost-1_42/boost/detail/binary_search.hpp" 1
# 34 "/usr/include/boost-1_42/boost/detail/binary_search.hpp"
namespace boost { namespace detail {

template <class ForwardIter, class Tp>
ForwardIter lower_bound(ForwardIter first, ForwardIter last,
                             const Tp& val)
{
    typedef detail::iterator_traits<ForwardIter> traits;

    typename traits::difference_type len = boost::detail::distance(first, last);
    typename traits::difference_type half;
    ForwardIter middle;

    while (len > 0) {
      half = len >> 1;
      middle = first;
      std::advance(middle, half);
      if (*middle < val) {
        first = middle;
        ++first;
        len = len - half - 1;
      }
      else
        len = half;
    }
    return first;
}

template <class ForwardIter, class Tp, class Compare>
ForwardIter lower_bound(ForwardIter first, ForwardIter last,
                              const Tp& val, Compare comp)
{
  typedef detail::iterator_traits<ForwardIter> traits;

  typename traits::difference_type len = boost::detail::distance(first, last);
  typename traits::difference_type half;
  ForwardIter middle;

  while (len > 0) {
    half = len >> 1;
    middle = first;
    std::advance(middle, half);
    if (comp(*middle, val)) {
      first = middle;
      ++first;
      len = len - half - 1;
    }
    else
      len = half;
  }
  return first;
}

template <class ForwardIter, class Tp>
ForwardIter upper_bound(ForwardIter first, ForwardIter last,
                           const Tp& val)
{
  typedef detail::iterator_traits<ForwardIter> traits;

  typename traits::difference_type len = boost::detail::distance(first, last);
  typename traits::difference_type half;
  ForwardIter middle;

  while (len > 0) {
    half = len >> 1;
    middle = first;
    std::advance(middle, half);
    if (val < *middle)
      len = half;
    else {
      first = middle;
      ++first;
      len = len - half - 1;
    }
  }
  return first;
}

template <class ForwardIter, class Tp, class Compare>
ForwardIter upper_bound(ForwardIter first, ForwardIter last,
                           const Tp& val, Compare comp)
{
  typedef detail::iterator_traits<ForwardIter> traits;

  typename traits::difference_type len = boost::detail::distance(first, last);
  typename traits::difference_type half;
  ForwardIter middle;

  while (len > 0) {
    half = len >> 1;
    middle = first;
    std::advance(middle, half);
    if (comp(val, *middle))
      len = half;
    else {
      first = middle;
      ++first;
      len = len - half - 1;
    }
  }
  return first;
}

template <class ForwardIter, class Tp>
std::pair<ForwardIter, ForwardIter>
equal_range(ForwardIter first, ForwardIter last, const Tp& val)
{
  typedef detail::iterator_traits<ForwardIter> traits;

  typename traits::difference_type len = boost::detail::distance(first, last);
  typename traits::difference_type half;
  ForwardIter middle, left, right;

  while (len > 0) {
    half = len >> 1;
    middle = first;
    std::advance(middle, half);
    if (*middle < val) {
      first = middle;
      ++first;
      len = len - half - 1;
    }
    else if (val < *middle)
      len = half;
    else {
      left = boost::detail::lower_bound(first, middle, val);
      std::advance(first, len);
      right = boost::detail::upper_bound(++middle, first, val);
      return std::pair<ForwardIter, ForwardIter>(left, right);
    }
  }
  return std::pair<ForwardIter, ForwardIter>(first, first);
}

template <class ForwardIter, class Tp, class Compare>
std::pair<ForwardIter, ForwardIter>
equal_range(ForwardIter first, ForwardIter last, const Tp& val,
              Compare comp)
{
  typedef detail::iterator_traits<ForwardIter> traits;

  typename traits::difference_type len = boost::detail::distance(first, last);
  typename traits::difference_type half;
  ForwardIter middle, left, right;

  while (len > 0) {
    half = len >> 1;
    middle = first;
    std::advance(middle, half);
    if (comp(*middle, val)) {
      first = middle;
      ++first;
      len = len - half - 1;
    }
    else if (comp(val, *middle))
      len = half;
    else {
      left = boost::detail::lower_bound(first, middle, val, comp);
      std::advance(first, len);
      right = boost::detail::upper_bound(++middle, first, val, comp);
      return std::pair<ForwardIter, ForwardIter>(left, right);
    }
  }
  return std::pair<ForwardIter, ForwardIter>(first, first);
}

template <class ForwardIter, class Tp>
bool binary_search(ForwardIter first, ForwardIter last,
                   const Tp& val) {
  ForwardIter i = boost::detail::lower_bound(first, last, val);
  return i != last && !(val < *i);
}

template <class ForwardIter, class Tp, class Compare>
bool binary_search(ForwardIter first, ForwardIter last,
                   const Tp& val,
                   Compare comp) {
  ForwardIter i = boost::detail::lower_bound(first, last, val, comp);
  return i != last && !comp(val, *i);
}

}}
# 13 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 2
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/cast.hpp" 1
# 32 "/usr/include/boost-1_42/boost/numeric/conversion/cast.hpp"
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/converter.hpp" 1
# 13 "/usr/include/boost-1_42/boost/numeric/conversion/converter.hpp"
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/conversion_traits.hpp" 1
# 13 "/usr/include/boost-1_42/boost/numeric/conversion/conversion_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 1
# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp"
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp" 1
# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/equal_to.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/equal_to.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 1
# 27 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 2







# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct equal_to_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct equal_to_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct equal_to_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct equal_to_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct equal_to_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct equal_to

    : equal_to_impl<
          typename equal_to_tag<N1>::type
        , typename equal_to_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   

};

template<> struct equal_to< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : equal_to< T1 , T2 > { }; }; template< typename Tag > struct lambda< equal_to< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef equal_to< na , na > result_; typedef equal_to< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< equal_to< T1 , T2 > > : int_<2> { }; template<> struct template_arity< equal_to< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {

template<>
struct equal_to_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N1::value == N2::value ) >
    {
    };
};

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 36 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 2
# 20 "/usr/include/boost-1_42/boost/mpl/equal_to.hpp" 2
# 18 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp" 2





namespace boost { namespace numeric { namespace convdetail
{
   template< class T1, class T2>
   struct equal_to
   {


       enum { x = ( T1::value == T2::value ) };

       static const bool value = x;

       typedef mpl::bool_<value> type;
# 48 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp"
   };
# 59 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp"
  template<class Value,
           class Case0Val,
           class Case1Val,
           class Case2Val,
           class Case0Type,
           class Case1Type,
           class Case2Type,
           class DefaultType
          >
  struct ct_switch4
  {
    typedef mpl::identity<Case0Type> Case0TypeQ ;
    typedef mpl::identity<Case1Type> Case1TypeQ ;

    typedef equal_to<Value,Case0Val> is_case0 ;
    typedef equal_to<Value,Case1Val> is_case1 ;
    typedef equal_to<Value,Case2Val> is_case2 ;

    typedef mpl::if_<is_case2,Case2Type,DefaultType> choose_2_3Q ;
    typedef mpl::eval_if<is_case1,Case1TypeQ,choose_2_3Q> choose_1_2_3Q ;

    typedef typename
      mpl::eval_if<is_case0,Case0TypeQ,choose_1_2_3Q>::type
        type ;
  } ;
# 97 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp"
  template<class expr0, class expr1, class TT, class TF, class FT, class FF>
  struct for_both
  {
    typedef mpl::identity<TF> TF_Q ;
    typedef mpl::identity<TT> TT_Q ;

    typedef typename mpl::not_<expr0>::type not_expr0 ;
    typedef typename mpl::not_<expr1>::type not_expr1 ;

    typedef typename mpl::and_<expr0,expr1>::type caseTT ;
    typedef typename mpl::and_<expr0,not_expr1>::type caseTF ;
    typedef typename mpl::and_<not_expr0,expr1>::type caseFT ;

    typedef mpl::if_<caseFT,FT,FF> choose_FT_FF_Q ;
    typedef mpl::eval_if<caseTF,TF_Q,choose_FT_FF_Q> choose_TF_FT_FF_Q ;

    typedef typename mpl::eval_if<caseTT,TT_Q,choose_TF_FT_FF_Q>::type type ;
  } ;

} } }
# 18 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/int_float_mixture.hpp" 1
# 16 "/usr/include/boost-1_42/boost/numeric/conversion/detail/int_float_mixture.hpp"
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/int_float_mixture_enum.hpp" 1
# 13 "/usr/include/boost-1_42/boost/numeric/conversion/int_float_mixture_enum.hpp"
namespace boost { namespace numeric
{
  enum int_float_mixture_enum
  {
     integral_to_integral
    ,integral_to_float
    ,float_to_integral
    ,float_to_float
  } ;

} }
# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/int_float_mixture.hpp" 2




namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<int_float_mixture_enum, integral_to_integral> int2int_c ;
  typedef mpl::integral_c<int_float_mixture_enum, integral_to_float> int2float_c ;
  typedef mpl::integral_c<int_float_mixture_enum, float_to_integral> float2int_c ;
  typedef mpl::integral_c<int_float_mixture_enum, float_to_float> float2float_c ;







  template<class T,class S>
  struct get_int_float_mixture
  {
    typedef mpl::bool_< ::std::numeric_limits<S>::is_integer > S_int ;
    typedef mpl::bool_< ::std::numeric_limits<T>::is_integer > T_int ;

    typedef typename
      for_both<S_int, T_int, int2int_c, int2float_c, float2int_c, float2float_c>::type
        type ;
  } ;
# 55 "/usr/include/boost-1_42/boost/numeric/conversion/detail/int_float_mixture.hpp"
  template<class IntFloatMixture, class Int2Int, class Int2Float, class Float2Int, class Float2Float>
  struct for_int_float_mixture
  {
    typedef typename
      ct_switch4<IntFloatMixture
                 ,int2int_c, int2float_c, float2int_c
                 ,Int2Int , Int2Float , Float2Int , Float2Float
                >::type
        type ;
  } ;

} } }
# 19 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/sign_mixture.hpp" 1
# 16 "/usr/include/boost-1_42/boost/numeric/conversion/detail/sign_mixture.hpp"
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/sign_mixture_enum.hpp" 1
# 13 "/usr/include/boost-1_42/boost/numeric/conversion/sign_mixture_enum.hpp"
namespace boost { namespace numeric
{
  enum sign_mixture_enum
  {
     unsigned_to_unsigned
    ,signed_to_signed
    ,signed_to_unsigned
    ,unsigned_to_signed
  } ;

} }
# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/sign_mixture.hpp" 2




namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_unsigned> unsig2unsig_c ;
  typedef mpl::integral_c<sign_mixture_enum, signed_to_signed> sig2sig_c ;
  typedef mpl::integral_c<sign_mixture_enum, signed_to_unsigned> sig2unsig_c ;
  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_signed> unsig2sig_c ;







  template<class T,class S>
  struct get_sign_mixture
  {
    typedef mpl::bool_< ::std::numeric_limits<S>::is_signed > S_signed ;
    typedef mpl::bool_< ::std::numeric_limits<T>::is_signed > T_signed ;

    typedef typename
      for_both<S_signed, T_signed, sig2sig_c, sig2unsig_c, unsig2sig_c, unsig2unsig_c>::type
        type ;
  } ;
# 55 "/usr/include/boost-1_42/boost/numeric/conversion/detail/sign_mixture.hpp"
  template<class SignMixture, class Sig2Sig, class Sig2Unsig, class Unsig2Sig, class Unsig2Unsig>
  struct for_sign_mixture
  {
    typedef typename
      ct_switch4<SignMixture
                 , sig2sig_c, sig2unsig_c, unsig2sig_c
                 , Sig2Sig , Sig2Unsig , Unsig2Sig , Unsig2Unsig
                >::type
        type ;
  } ;

} } }
# 20 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 1
# 15 "/usr/include/boost-1_42/boost/numeric/conversion/detail/udt_builtin_mixture.hpp"
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/udt_builtin_mixture_enum.hpp" 1
# 13 "/usr/include/boost-1_42/boost/numeric/conversion/udt_builtin_mixture_enum.hpp"
namespace boost { namespace numeric
{
  enum udt_builtin_mixture_enum
  {
     builtin_to_builtin
    ,builtin_to_udt
    ,udt_to_builtin
    ,udt_to_udt
  } ;

} }
# 16 "/usr/include/boost-1_42/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 2




namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_builtin> builtin2builtin_c ;
  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_udt> builtin2udt_c ;
  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_builtin> udt2builtin_c ;
  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_udt> udt2udt_c ;
# 37 "/usr/include/boost-1_42/boost/numeric/conversion/detail/udt_builtin_mixture.hpp"
  template<class UdtMixture, class BuiltIn2BuiltIn, class BuiltIn2Udt, class Udt2BuiltIn, class Udt2Udt>
  struct for_udt_builtin_mixture
  {
    typedef typename
      ct_switch4<UdtMixture
                 , builtin2builtin_c, builtin2udt_c, udt2builtin_c
                 , BuiltIn2BuiltIn , BuiltIn2Udt , Udt2BuiltIn , Udt2Udt
                >::type
        type ;
  } ;







  template<class T,class S>
  struct get_udt_builtin_mixture
  {
    typedef is_arithmetic<S> S_builtin ;
    typedef is_arithmetic<T> T_builtin ;

    typedef typename
      for_both<S_builtin, T_builtin, builtin2builtin_c, builtin2udt_c, udt2builtin_c, udt2udt_c>::type
        type ;
  } ;

} } }
# 21 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 2
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/is_subranged.hpp" 1
# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/is_subranged.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/multiplies.hpp" 1
# 17 "/usr/include/boost-1_42/boost/mpl/multiplies.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/times.hpp" 1
# 19 "/usr/include/boost-1_42/boost/mpl/times.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 1
# 26 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
# 27 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2







# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/times.hpp" 1
# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/times.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct times_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct times_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct times_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct times_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct times_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    , typename N3 = na, typename N4 = na, typename N5 = na
    >
struct times
    : times< times< times< times< N1,N2 >, N3>, N4>, N5>
{
   




};

template<
      typename N1, typename N2, typename N3, typename N4
    >
struct times< N1,N2,N3,N4,na >

    : times< times< times< N1,N2 >, N3>, N4>
{
   




};

template<
      typename N1, typename N2, typename N3
    >
struct times< N1,N2,N3,na,na >

    : times< times< N1,N2 >, N3>
{
   




};

template<
      typename N1, typename N2
    >
struct times< N1,N2,na,na,na >
    : times_impl<
          typename times_tag<N1>::type
        , typename times_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   





};

template<> struct times< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : times< T1 , T2 > { }; }; template< typename Tag > struct lambda< times< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef times< na , na > result_; typedef times< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< times< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< times< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {
template<>
struct times_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : integral_c<
              typename aux::largest_int<
                  typename N1::value_type
                , typename N2::value_type
                >::type
            , ( N1::value
                  * N2::value
                )
            >
    {
    };
};

}}
# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
# 35 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2
# 20 "/usr/include/boost-1_42/boost/mpl/times.hpp" 2
# 18 "/usr/include/boost-1_42/boost/mpl/multiplies.hpp" 2


# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/default_params.hpp" 1
# 21 "/usr/include/boost-1_42/boost/mpl/multiplies.hpp" 2





namespace boost { namespace mpl {







template<
      typename N1 = na , typename N2 = na , typename N3 = na , typename N4 = na , typename N5 = na
    >
struct multiplies
    : times< N1 , N2 , N3 , N4 , N5 >
{
   




};

template<> struct multiplies< na , na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct apply : multiplies< T1 , T2 , T3 , T4 , T5 > { }; }; template< typename Tag > struct lambda< multiplies< na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef multiplies< na , na , na , na , na > result_; typedef multiplies< na , na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< multiplies< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< multiplies< na , na , na , na , na > > : int_<-1> { }; }



}}
# 18 "/usr/include/boost-1_42/boost/numeric/conversion/detail/is_subranged.hpp" 2
# 28 "/usr/include/boost-1_42/boost/numeric/conversion/detail/is_subranged.hpp"
namespace boost { namespace numeric { namespace convdetail
{





    template<class T,class S>
    struct subranged_Sig2Unsig
    {


      typedef mpl::true_ type ;
    } ;


    template<class T,class S>
    struct subranged_Unsig2Sig
    {
# 62 "/usr/include/boost-1_42/boost/numeric/conversion/detail/is_subranged.hpp"
       typedef mpl::int_< ::std::numeric_limits<S>::digits > S_digits ;
       typedef mpl::int_< ::std::numeric_limits<T>::digits > T_digits ;


       typedef typename T_digits::next u_T_digits ;

       typedef mpl::int_<2> Two ;

       typedef typename mpl::multiplies<S_digits,Two>::type S_digits_times_2 ;

       typedef typename mpl::less<u_T_digits,S_digits_times_2>::type type ;
    } ;


    template<class T,class S>
    struct subranged_SameSign
    {


       typedef mpl::int_< ::std::numeric_limits<S>::digits > S_digits ;
       typedef mpl::int_< ::std::numeric_limits<T>::digits > T_digits ;

       typedef typename mpl::less<T_digits,S_digits>::type type ;
    } ;


    template<class T,class S>
    struct subranged_Int2Float
    {
      typedef mpl::false_ type ;
    } ;


    template<class T,class S>
    struct subranged_Float2Int
    {
      typedef mpl::true_ type ;
    } ;


    template<class T,class S>
    struct subranged_Float2Float
    {



      typedef mpl::int_< ::std::numeric_limits<S>::digits > S_mantisa ;
      typedef mpl::int_< ::std::numeric_limits<T>::digits > T_mantisa ;

      typedef mpl::int_< ::std::numeric_limits<S>::max_exponent > S_exponent ;
      typedef mpl::int_< ::std::numeric_limits<T>::max_exponent > T_exponent ;

      typedef typename mpl::less<T_exponent,S_exponent>::type T_smaller_exponent ;

      typedef typename mpl::equal_to<T_exponent,S_exponent>::type equal_exponents ;

      typedef mpl::less<T_mantisa,S_mantisa> T_smaller_mantisa ;

      typedef mpl::eval_if<equal_exponents,T_smaller_mantisa,mpl::false_> not_bigger_exponent_case ;

      typedef typename
        mpl::eval_if<T_smaller_exponent,mpl::true_,not_bigger_exponent_case>::type
          type ;
    } ;


    template<class T,class S>
    struct subranged_Udt2BuiltIn
    {
      typedef mpl::true_ type ;
    } ;


    template<class T,class S>
    struct subranged_BuiltIn2Udt
    {
      typedef mpl::false_ type ;
    } ;


    template<class T,class S>
    struct subranged_Udt2Udt
    {
      typedef mpl::false_ type ;
    } ;





    template<class T,class S>
    struct get_subranged_Int2Int
    {
      typedef subranged_SameSign<T,S> Sig2Sig ;
      typedef subranged_Sig2Unsig<T,S> Sig2Unsig ;
      typedef subranged_Unsig2Sig<T,S> Unsig2Sig ;
      typedef Sig2Sig Unsig2Unsig ;

      typedef typename get_sign_mixture<T,S>::type sign_mixture ;

      typedef typename
        for_sign_mixture<sign_mixture, Sig2Sig, Sig2Unsig, Unsig2Sig, Unsig2Unsig>::type
           type ;
    } ;

    template<class T,class S>
    struct get_subranged_BuiltIn2BuiltIn
    {
      typedef get_subranged_Int2Int<T,S> Int2IntQ ;

      typedef subranged_Int2Float <T,S> Int2Float ;
      typedef subranged_Float2Int <T,S> Float2Int ;
      typedef subranged_Float2Float<T,S> Float2Float ;

      typedef mpl::identity<Int2Float > Int2FloatQ ;
      typedef mpl::identity<Float2Int > Float2IntQ ;
      typedef mpl::identity<Float2Float> Float2FloatQ ;

      typedef typename get_int_float_mixture<T,S>::type int_float_mixture ;

      typedef for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ> for_ ;

      typedef typename for_::type selected ;

      typedef typename selected::type type ;
    } ;

    template<class T,class S>
    struct get_subranged
    {
      typedef get_subranged_BuiltIn2BuiltIn<T,S> BuiltIn2BuiltInQ ;

      typedef subranged_BuiltIn2Udt<T,S> BuiltIn2Udt ;
      typedef subranged_Udt2BuiltIn<T,S> Udt2BuiltIn ;
      typedef subranged_Udt2Udt<T,S> Udt2Udt ;

      typedef mpl::identity<BuiltIn2Udt> BuiltIn2UdtQ ;
      typedef mpl::identity<Udt2BuiltIn> Udt2BuiltInQ ;
      typedef mpl::identity<Udt2Udt > Udt2UdtQ ;

      typedef typename get_udt_builtin_mixture<T,S>::type udt_builtin_mixture ;

      typedef typename
        for_udt_builtin_mixture<udt_builtin_mixture, BuiltIn2BuiltInQ, BuiltIn2UdtQ, Udt2BuiltInQ, Udt2UdtQ>::type
          selected ;

      typedef typename selected::type selected2 ;

      typedef typename selected2::type type ;
    } ;





  template<class T, class S>
  struct get_is_subranged
  {
    typedef get_subranged<T,S> non_trivial_case ;
    typedef mpl::identity<mpl::false_> trivial_case ;

    typedef is_same<T,S> is_trivial ;

    typedef typename mpl::if_<is_trivial,trivial_case,non_trivial_case>::type selected ;

    typedef typename selected::type type ;
  } ;

} } }
# 22 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 2

namespace boost { namespace numeric { namespace convdetail
{





  template<class T,class S>
  struct non_trivial_traits_impl
  {
    typedef typename get_int_float_mixture <T,S>::type int_float_mixture ;
    typedef typename get_sign_mixture <T,S>::type sign_mixture ;
    typedef typename get_udt_builtin_mixture <T,S>::type udt_builtin_mixture ;

    typedef typename get_is_subranged<T,S>::type subranged ;

    typedef mpl::false_ trivial ;

    typedef T target_type ;
    typedef S source_type ;
    typedef T result_type ;

    typedef typename mpl::if_< is_arithmetic<S>, S, S const&>::type argument_type ;

    typedef typename mpl::if_<subranged,S,T>::type supertype ;
    typedef typename mpl::if_<subranged,T,S>::type subtype ;
  } ;






  template<class N>
  struct trivial_traits_impl
  {
    typedef typename get_int_float_mixture <N,N>::type int_float_mixture ;
    typedef typename get_sign_mixture <N,N>::type sign_mixture ;
    typedef typename get_udt_builtin_mixture<N,N>::type udt_builtin_mixture ;

    typedef mpl::false_ subranged ;
    typedef mpl::true_ trivial ;

    typedef N target_type ;
    typedef N source_type ;
    typedef N const& result_type ;
    typedef N const& argument_type ;

    typedef N supertype ;
    typedef N subtype ;

  } ;




  template<class T, class S>
  struct get_conversion_traits
  {
    typedef typename remove_cv<T>::type target_type ;
    typedef typename remove_cv<S>::type source_type ;

    typedef typename is_same<target_type,source_type>::type is_trivial ;

    typedef trivial_traits_impl <target_type> trivial_imp ;
    typedef non_trivial_traits_impl<target_type,source_type> non_trivial_imp ;

    typedef typename mpl::if_<is_trivial,trivial_imp,non_trivial_imp>::type type ;
  } ;

} } }
# 14 "/usr/include/boost-1_42/boost/numeric/conversion/conversion_traits.hpp" 2



namespace boost { namespace numeric
{

template<class T, class S>
struct conversion_traits
    : convdetail::get_conversion_traits<T,S>::type
{







} ;

} }
# 14 "/usr/include/boost-1_42/boost/numeric/conversion/converter.hpp" 2
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/converter_policies.hpp" 1
# 15 "/usr/include/boost-1_42/boost/numeric/conversion/converter_policies.hpp"
# 1 "/usr/include/boost-1_42/boost/config/no_tr1/cmath.hpp" 1
# 21 "/usr/include/boost-1_42/boost/config/no_tr1/cmath.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
# 22 "/usr/include/boost-1_42/boost/config/no_tr1/cmath.hpp" 2
# 16 "/usr/include/boost-1_42/boost/numeric/conversion/converter_policies.hpp" 2
# 24 "/usr/include/boost-1_42/boost/numeric/conversion/converter_policies.hpp"
namespace boost { namespace numeric
{

template<class S>
struct Trunc
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {

    using std::floor ;
    using std::ceil ;


    return s < static_cast<S>(0) ? ceil(s) : floor(s) ;
  }

  typedef mpl::integral_c< std::float_round_style, std::round_toward_zero> round_style ;
} ;



template<class S>
struct Floor
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {

    using std::floor ;


    return floor(s) ;
  }

  typedef mpl::integral_c< std::float_round_style, std::round_toward_neg_infinity> round_style ;
} ;

template<class S>
struct Ceil
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {

    using std::ceil ;


    return ceil(s) ;
  }

  typedef mpl::integral_c< std::float_round_style, std::round_toward_infinity> round_style ;
} ;

template<class S>
struct RoundEven
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {



    using std::floor ;
    using std::ceil ;



    S prev = floor(s);
    S next = ceil(s);

    S rt = (s - prev) - (next - s);

    S const zero(0.0);
    S const two(2.0);

    if ( rt < zero )
      return prev;
    else if ( rt > zero )
      return next;
    else
    {
      bool is_prev_even = two * floor(prev / two) == prev ;
      return ( is_prev_even ? prev : next ) ;
    }
  }

  typedef mpl::integral_c< std::float_round_style, std::round_to_nearest> round_style ;
} ;


enum range_check_result
{
  cInRange = 0 ,
  cNegOverflow = 1 ,
  cPosOverflow = 2
} ;

class bad_numeric_cast : public std::bad_cast
{
  public:

    virtual const char * what() const throw()
      { return "bad numeric conversion: overflow"; }
};

class negative_overflow : public bad_numeric_cast
{
  public:

    virtual const char * what() const throw()
      { return "bad numeric conversion: negative overflow"; }
};
class positive_overflow : public bad_numeric_cast
{
  public:

    virtual const char * what() const throw()
      { return "bad numeric conversion: positive overflow"; }
};

struct def_overflow_handler
{
  void operator() ( range_check_result r )
  {
    if ( r == cNegOverflow )
      throw negative_overflow() ;
    else if ( r == cPosOverflow )
           throw positive_overflow() ;
  }
} ;

struct silent_overflow_handler
{
  void operator() ( range_check_result ) {}
} ;

template<class Traits>
struct raw_converter
{
  typedef typename Traits::result_type result_type ;
  typedef typename Traits::argument_type argument_type ;

  static result_type low_level_convert ( argument_type s ) { return static_cast<result_type>(s) ; }
} ;

struct UseInternalRangeChecker {} ;

} }
# 15 "/usr/include/boost-1_42/boost/numeric/conversion/converter.hpp" 2

# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp" 1
# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/bounds.hpp" 1
# 13 "/usr/include/boost-1_42/boost/numeric/conversion/bounds.hpp"
# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/bounds.hpp" 1
# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/bounds.hpp"
namespace boost { namespace numeric { namespace boundsdetail
{
  template<class N>
  class Integral
  {
      typedef std::numeric_limits<N> limits ;

    public :

      static N lowest () { return limits::min (); }
      static N highest () { return limits::max (); }
      static N smallest() { return static_cast<N>(1); }
  } ;

  template<class N>
  class Float
  {
      typedef std::numeric_limits<N> limits ;

    public :

      static N lowest () { return static_cast<N>(-limits::max ()) ; }
      static N highest () { return limits::max (); }
      static N smallest() { return limits::min (); }
  } ;

  template<class N>
  struct get_impl
  {
    typedef mpl::bool_< ::std::numeric_limits<N>::is_integer > is_int ;

    typedef Integral<N> impl_int ;
    typedef Float <N> impl_float ;

    typedef typename mpl::if_<is_int,impl_int,impl_float>::type type ;
  } ;

} } }
# 14 "/usr/include/boost-1_42/boost/numeric/conversion/bounds.hpp" 2

namespace boost { namespace numeric
{

template<class N>
struct bounds : boundsdetail::get_impl<N>::type
{} ;

} }
# 18 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp" 2





namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<std::float_round_style, std::round_toward_zero> round2zero_c ;
  typedef mpl::integral_c<std::float_round_style, std::round_to_nearest> round2nearest_c ;
  typedef mpl::integral_c<std::float_round_style, std::round_toward_infinity> round2inf_c ;
  typedef mpl::integral_c<std::float_round_style, std::round_toward_neg_infinity> round2neg_inf_c ;
# 40 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
  template<class RoundStyle,class RoundToZero,class RoundToNearest,class RoundToInf,class RoundToNegInf>
  struct for_round_style
  {
    typedef ct_switch4<RoundStyle
                       , round2zero_c, round2nearest_c, round2inf_c
                       , RoundToZero , RoundToNearest , RoundToInf , RoundToNegInf
                      > selector ;

    typedef typename selector::type type ;
  } ;
# 81 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
  struct non_applicable { typedef mpl::false_ do_apply ; } ;
  struct applicable { typedef mpl::true_ do_apply ; } ;
# 96 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
    template<class Traits>
    struct LT_LoT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s < static_cast<S>(bounds<T>::lowest()) ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct LT_Zero : applicable
    {
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s < static_cast<S>(0) ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct LE_PrevLoT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s <= static_cast<S>(bounds<T>::lowest()) - static_cast<S>(1.0)
                 ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct LT_HalfPrevLoT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s < static_cast<S>(bounds<T>::lowest()) - static_cast<S>(0.5)
                 ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct GT_HiT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s > static_cast<S>(bounds<T>::highest())
                 ? cPosOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct GE_SuccHiT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(1.0)
                 ? cPosOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct GT_HalfSuccHiT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(0.5)
                 ? cPosOverflow : cInRange ;
      }
    } ;
# 215 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
    template<class PredA, class PredB>
    struct applyBoth
    {
      typedef typename PredA::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        range_check_result r = PredA::apply(s) ;
        if ( r == cInRange )
          r = PredB::apply(s);
        return r ;
      }
    } ;

    template<class PredA, class PredB>
    struct combine
    {
      typedef applyBoth<PredA,PredB> Both ;
      typedef void NNone ;

      typedef typename PredA::do_apply do_applyA ;
      typedef typename PredB::do_apply do_applyB ;

      typedef typename for_both<do_applyA, do_applyB, Both, PredA, PredB, NNone>::type type ;
    } ;
# 262 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
  template<class Traits>
  struct dummy_range_checker
  {
    typedef typename Traits::argument_type argument_type ;

    static range_check_result out_of_range ( argument_type ) { return cInRange ; }
    static void validate_range ( argument_type ) {}
  } ;
# 279 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
  template<class Traits, class IsNegOverflow, class IsPosOverflow, class OverflowHandler>
  struct generic_range_checker
  {
    typedef OverflowHandler overflow_handler ;

    typedef typename Traits::argument_type argument_type ;

    static range_check_result out_of_range ( argument_type s )
    {
      typedef typename combine<IsNegOverflow,IsPosOverflow>::type Predicate ;

      return Predicate::apply(s);
    }

    static void validate_range ( argument_type s )
      { OverflowHandler()( out_of_range(s) ) ; }
  } ;
# 305 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
  template<class Traits,class OverflowHandler>
  struct GetRC_Sig2Sig_or_Unsig2Unsig
  {
    typedef dummy_range_checker<Traits> Dummy ;

    typedef LT_LoT<Traits> Pred1 ;
    typedef GT_HiT<Traits> Pred2 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ;

    typedef typename Traits::subranged subranged ;

    typedef typename mpl::if_<subranged,Normal,Dummy>::type type ;
  } ;

  template<class Traits, class OverflowHandler>
  struct GetRC_Sig2Unsig
  {
    typedef LT_Zero<Traits> Pred1 ;
    typedef GT_HiT <Traits> Pred2 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ChoiceA ;

    typedef generic_range_checker<Traits,Pred1,non_applicable,OverflowHandler> ChoiceB ;

    typedef typename Traits::target_type T ;
    typedef typename Traits::source_type S ;

    typedef typename subranged_Unsig2Sig<S,T>::type oposite_subranged ;

    typedef typename mpl::not_<oposite_subranged>::type positively_subranged ;

    typedef typename mpl::if_<positively_subranged,ChoiceA,ChoiceB>::type type ;
  } ;

  template<class Traits, class OverflowHandler>
  struct GetRC_Unsig2Sig
  {
    typedef GT_HiT<Traits> Pred1 ;

    typedef generic_range_checker<Traits,non_applicable,Pred1,OverflowHandler> type ;
  } ;

  template<class Traits,class OverflowHandler>
  struct GetRC_Int2Int
  {
    typedef GetRC_Sig2Sig_or_Unsig2Unsig<Traits,OverflowHandler> Sig2SigQ ;
    typedef GetRC_Sig2Unsig <Traits,OverflowHandler> Sig2UnsigQ ;
    typedef GetRC_Unsig2Sig <Traits,OverflowHandler> Unsig2SigQ ;
    typedef Sig2SigQ Unsig2UnsigQ ;

    typedef typename Traits::sign_mixture sign_mixture ;

    typedef typename
      for_sign_mixture<sign_mixture,Sig2SigQ,Sig2UnsigQ,Unsig2SigQ,Unsig2UnsigQ>::type
        selector ;

    typedef typename selector::type type ;
  } ;

  template<class Traits>
  struct GetRC_Int2Float
  {
    typedef dummy_range_checker<Traits> type ;
  } ;

  template<class Traits, class OverflowHandler, class Float2IntRounder>
  struct GetRC_Float2Int
  {
    typedef LE_PrevLoT <Traits> Pred1 ;
    typedef GE_SuccHiT <Traits> Pred2 ;
    typedef LT_HalfPrevLoT<Traits> Pred3 ;
    typedef GT_HalfSuccHiT<Traits> Pred4 ;
    typedef GT_HiT <Traits> Pred5 ;
    typedef LT_LoT <Traits> Pred6 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ToZero ;
    typedef generic_range_checker<Traits,Pred3,Pred4,OverflowHandler> ToNearest ;
    typedef generic_range_checker<Traits,Pred1,Pred5,OverflowHandler> ToInf ;
    typedef generic_range_checker<Traits,Pred6,Pred2,OverflowHandler> ToNegInf ;

    typedef typename Float2IntRounder::round_style round_style ;

    typedef typename for_round_style<round_style,ToZero,ToNearest,ToInf,ToNegInf>::type type ;
  } ;

  template<class Traits, class OverflowHandler>
  struct GetRC_Float2Float
  {
    typedef dummy_range_checker<Traits> Dummy ;

    typedef LT_LoT<Traits> Pred1 ;
    typedef GT_HiT<Traits> Pred2 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ;

    typedef typename Traits::subranged subranged ;

    typedef typename mpl::if_<subranged,Normal,Dummy>::type type ;
  } ;

  template<class Traits, class OverflowHandler, class Float2IntRounder>
  struct GetRC_BuiltIn2BuiltIn
  {
    typedef GetRC_Int2Int<Traits,OverflowHandler> Int2IntQ ;
    typedef GetRC_Int2Float<Traits> Int2FloatQ ;
    typedef GetRC_Float2Int<Traits,OverflowHandler,Float2IntRounder> Float2IntQ ;
    typedef GetRC_Float2Float<Traits,OverflowHandler> Float2FloatQ ;

    typedef typename Traits::int_float_mixture int_float_mixture ;

    typedef typename for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ>::type selector ;

    typedef typename selector::type type ;
  } ;

  template<class Traits, class OverflowHandler, class Float2IntRounder>
  struct GetRC
  {
    typedef GetRC_BuiltIn2BuiltIn<Traits,OverflowHandler,Float2IntRounder> BuiltIn2BuiltInQ ;

    typedef dummy_range_checker<Traits> Dummy ;

    typedef mpl::identity<Dummy> DummyQ ;

    typedef typename Traits::udt_builtin_mixture udt_builtin_mixture ;

    typedef typename for_udt_builtin_mixture<udt_builtin_mixture,BuiltIn2BuiltInQ,DummyQ,DummyQ,DummyQ>::type selector ;

    typedef typename selector::type type ;
  } ;
# 452 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
  template<class Traits>
  struct trivial_converter_impl : public std::unary_function< typename Traits::argument_type
                                                              ,typename Traits::result_type
                                                            >
                                 ,public dummy_range_checker<Traits>
  {
    typedef Traits traits ;

    typedef typename Traits::source_type source_type ;
    typedef typename Traits::argument_type argument_type ;
    typedef typename Traits::result_type result_type ;

    static result_type low_level_convert ( argument_type s ) { return s ; }
    static source_type nearbyint ( argument_type s ) { return s ; }
    static result_type convert ( argument_type s ) { return s ; }
  } ;





  template<class Traits,class RangeChecker,class RawConverter,class Float2IntRounder>
  struct rounding_converter : public std::unary_function< typename Traits::argument_type
                                                          ,typename Traits::result_type
                                                        >
                             ,public RangeChecker
                             ,public Float2IntRounder
                             ,public RawConverter
  {
    typedef RangeChecker RangeCheckerBase ;
    typedef Float2IntRounder Float2IntRounderBase ;
    typedef RawConverter RawConverterBase ;

    typedef Traits traits ;

    typedef typename Traits::source_type source_type ;
    typedef typename Traits::argument_type argument_type ;
    typedef typename Traits::result_type result_type ;

    static result_type convert ( argument_type s )
    {
      RangeCheckerBase::validate_range(s);
      source_type s1 = Float2IntRounderBase::nearbyint(s);
      return RawConverterBase::low_level_convert(s1);
    }
  } ;





  template<class Traits,class RangeChecker,class RawConverter>
  struct non_rounding_converter : public std::unary_function< typename Traits::argument_type
                                                             ,typename Traits::result_type
                                                           >
                                 ,public RangeChecker
                                 ,public RawConverter
  {
    typedef RangeChecker RangeCheckerBase ;
    typedef RawConverter RawConverterBase ;

    typedef Traits traits ;

    typedef typename Traits::source_type source_type ;
    typedef typename Traits::argument_type argument_type ;
    typedef typename Traits::result_type result_type ;

    static source_type nearbyint ( argument_type s ) { return s ; }

    static result_type convert ( argument_type s )
    {
      RangeCheckerBase::validate_range(s);
      return RawConverterBase::low_level_convert(s);
    }
  } ;
# 537 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
  template<class Traits,class OverflowHandler,class Float2IntRounder,class RawConverter, class UserRangeChecker>
  struct get_non_trivial_converter
  {
    typedef GetRC<Traits,OverflowHandler,Float2IntRounder> InternalRangeCheckerQ ;

    typedef is_same<UserRangeChecker,UseInternalRangeChecker> use_internal_RC ;

    typedef mpl::identity<UserRangeChecker> UserRangeCheckerQ ;

    typedef typename
      mpl::eval_if<use_internal_RC,InternalRangeCheckerQ,UserRangeCheckerQ>::type
        RangeChecker ;

    typedef non_rounding_converter<Traits,RangeChecker,RawConverter> NonRounding ;
    typedef rounding_converter<Traits,RangeChecker,RawConverter,Float2IntRounder> Rounding ;

    typedef mpl::identity<NonRounding> NonRoundingQ ;
    typedef mpl::identity<Rounding> RoundingQ ;

    typedef typename Traits::int_float_mixture int_float_mixture ;

    typedef typename
      for_int_float_mixture<int_float_mixture, NonRoundingQ, NonRoundingQ, RoundingQ, NonRoundingQ>::type
        selector ;

    typedef typename selector::type type ;
  } ;

  template< class Traits
           ,class OverflowHandler
           ,class Float2IntRounder
           ,class RawConverter
           ,class UserRangeChecker
          >
  struct get_converter_impl
  {
# 583 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
    typedef trivial_converter_impl<Traits> Trivial ;
    typedef mpl::identity <Trivial> TrivialQ ;

    typedef get_non_trivial_converter< Traits
                                      ,OverflowHandler
                                      ,Float2IntRounder
                                      ,RawConverter
                                      ,UserRangeChecker
                                     > NonTrivialQ ;

    typedef typename Traits::trivial trivial ;

    typedef typename mpl::eval_if<trivial,TrivialQ,NonTrivialQ>::type type ;
  } ;

} } }
# 17 "/usr/include/boost-1_42/boost/numeric/conversion/converter.hpp" 2

namespace boost { namespace numeric
{

template<class T,
         class S,
         class Traits = conversion_traits<T,S>,
         class OverflowHandler = def_overflow_handler,
         class Float2IntRounder = Trunc< typename Traits::source_type> ,
         class RawConverter = raw_converter<Traits>,
         class UserRangeChecker = UseInternalRangeChecker
        >
struct converter : convdetail::get_converter_impl<Traits,
                                                  OverflowHandler,
                                                  Float2IntRounder,
                                                  RawConverter,
                                                  UserRangeChecker
                                                 >::type
{
  typedef Traits traits ;

  typedef typename Traits::argument_type argument_type ;
  typedef typename Traits::result_type result_type ;

  result_type operator() ( argument_type s ) const { return this->convert(s) ; }
} ;



template<class S,
         class OverflowHandler = def_overflow_handler,
         class Float2IntRounder = Trunc<S> ,
         class UserRangeChecker = UseInternalRangeChecker
        >
struct make_converter_from
{
  template<class T,
           class Traits = conversion_traits<T,S>,
           class RawConverter = raw_converter<Traits>
          >
  struct to
  {
    typedef converter<T,S,Traits,OverflowHandler,Float2IntRounder,RawConverter,UserRangeChecker> type ;
  } ;

} ;

} }
# 33 "/usr/include/boost-1_42/boost/numeric/conversion/cast.hpp" 2

namespace boost
{
  template<typename Target, typename Source>
  inline
  Target numeric_cast ( Source arg )
  {
    typedef boost::numeric::converter<Target,Source> Converter ;
    return Converter::convert(arg);
  }

  using numeric::bad_numeric_cast;

}
# 14 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 2


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 3
       
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 1 3
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
  enum _Rb_tree_color { _S_red = false, _S_black = true };

  struct _Rb_tree_node_base
  {
    typedef _Rb_tree_node_base* _Base_ptr;
    typedef const _Rb_tree_node_base* _Const_Base_ptr;

    _Rb_tree_color _M_color;
    _Base_ptr _M_parent;
    _Base_ptr _M_left;
    _Base_ptr _M_right;

    static _Base_ptr
    _S_minimum(_Base_ptr __x)
    {
      while (__x->_M_left != 0) __x = __x->_M_left;
      return __x;
    }

    static _Const_Base_ptr
    _S_minimum(_Const_Base_ptr __x)
    {
      while (__x->_M_left != 0) __x = __x->_M_left;
      return __x;
    }

    static _Base_ptr
    _S_maximum(_Base_ptr __x)
    {
      while (__x->_M_right != 0) __x = __x->_M_right;
      return __x;
    }

    static _Const_Base_ptr
    _S_maximum(_Const_Base_ptr __x)
    {
      while (__x->_M_right != 0) __x = __x->_M_right;
      return __x;
    }
  };

  template<typename _Val>
    struct _Rb_tree_node : public _Rb_tree_node_base
    {
      typedef _Rb_tree_node<_Val>* _Link_type;
      _Val _M_value_field;







    };

  __attribute__ ((__pure__)) _Rb_tree_node_base*
  _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();

  __attribute__ ((__pure__)) const _Rb_tree_node_base*
  _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();

  __attribute__ ((__pure__)) _Rb_tree_node_base*
  _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();

  __attribute__ ((__pure__)) const _Rb_tree_node_base*
  _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();

  template<typename _Tp>
    struct _Rb_tree_iterator
    {
      typedef _Tp value_type;
      typedef _Tp& reference;
      typedef _Tp* pointer;

      typedef bidirectional_iterator_tag iterator_category;
      typedef ptrdiff_t difference_type;

      typedef _Rb_tree_iterator<_Tp> _Self;
      typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
      typedef _Rb_tree_node<_Tp>* _Link_type;

      _Rb_tree_iterator()
      : _M_node() { }

      explicit
      _Rb_tree_iterator(_Link_type __x)
      : _M_node(__x) { }

      reference
      operator*() const
      { return static_cast<_Link_type>(_M_node)->_M_value_field; }

      pointer
      operator->() const
      { return &static_cast<_Link_type>(_M_node)->_M_value_field; }

      _Self&
      operator++()
      {
 _M_node = _Rb_tree_increment(_M_node);
 return *this;
      }

      _Self
      operator++(int)
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_increment(_M_node);
 return __tmp;
      }

      _Self&
      operator--()
      {
 _M_node = _Rb_tree_decrement(_M_node);
 return *this;
      }

      _Self
      operator--(int)
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_decrement(_M_node);
 return __tmp;
      }

      bool
      operator==(const _Self& __x) const
      { return _M_node == __x._M_node; }

      bool
      operator!=(const _Self& __x) const
      { return _M_node != __x._M_node; }

      _Base_ptr _M_node;
  };

  template<typename _Tp>
    struct _Rb_tree_const_iterator
    {
      typedef _Tp value_type;
      typedef const _Tp& reference;
      typedef const _Tp* pointer;

      typedef _Rb_tree_iterator<_Tp> iterator;

      typedef bidirectional_iterator_tag iterator_category;
      typedef ptrdiff_t difference_type;

      typedef _Rb_tree_const_iterator<_Tp> _Self;
      typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
      typedef const _Rb_tree_node<_Tp>* _Link_type;

      _Rb_tree_const_iterator()
      : _M_node() { }

      explicit
      _Rb_tree_const_iterator(_Link_type __x)
      : _M_node(__x) { }

      _Rb_tree_const_iterator(const iterator& __it)
      : _M_node(__it._M_node) { }

      reference
      operator*() const
      { return static_cast<_Link_type>(_M_node)->_M_value_field; }

      pointer
      operator->() const
      { return &static_cast<_Link_type>(_M_node)->_M_value_field; }

      _Self&
      operator++()
      {
 _M_node = _Rb_tree_increment(_M_node);
 return *this;
      }

      _Self
      operator++(int)
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_increment(_M_node);
 return __tmp;
      }

      _Self&
      operator--()
      {
 _M_node = _Rb_tree_decrement(_M_node);
 return *this;
      }

      _Self
      operator--(int)
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_decrement(_M_node);
 return __tmp;
      }

      bool
      operator==(const _Self& __x) const
      { return _M_node == __x._M_node; }

      bool
      operator!=(const _Self& __x) const
      { return _M_node != __x._M_node; }

      _Base_ptr _M_node;
    };

  template<typename _Val>
    inline bool
    operator==(const _Rb_tree_iterator<_Val>& __x,
               const _Rb_tree_const_iterator<_Val>& __y)
    { return __x._M_node == __y._M_node; }

  template<typename _Val>
    inline bool
    operator!=(const _Rb_tree_iterator<_Val>& __x,
               const _Rb_tree_const_iterator<_Val>& __y)
    { return __x._M_node != __y._M_node; }

  void
  _Rb_tree_insert_and_rebalance(const bool __insert_left,
                                _Rb_tree_node_base* __x,
                                _Rb_tree_node_base* __p,
                                _Rb_tree_node_base& __header) throw ();

  _Rb_tree_node_base*
  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
          _Rb_tree_node_base& __header) throw ();


  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc = allocator<_Val> >
    class _Rb_tree
    {
      typedef typename _Alloc::template rebind<_Rb_tree_node<_Val> >::other
              _Node_allocator;

    protected:
      typedef _Rb_tree_node_base* _Base_ptr;
      typedef const _Rb_tree_node_base* _Const_Base_ptr;

    public:
      typedef _Key key_type;
      typedef _Val value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef _Rb_tree_node<_Val>* _Link_type;
      typedef const _Rb_tree_node<_Val>* _Const_Link_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

      _Node_allocator&
      _M_get_Node_allocator()
      { return *static_cast<_Node_allocator*>(&this->_M_impl); }

      const _Node_allocator&
      _M_get_Node_allocator() const
      { return *static_cast<const _Node_allocator*>(&this->_M_impl); }

      allocator_type
      get_allocator() const
      { return allocator_type(_M_get_Node_allocator()); }

    protected:
      _Link_type
      _M_get_node()
      { return _M_impl._Node_allocator::allocate(1); }

      void
      _M_put_node(_Link_type __p)
      { _M_impl._Node_allocator::deallocate(__p, 1); }


      _Link_type
      _M_create_node(const value_type& __x)
      {
 _Link_type __tmp = _M_get_node();
 try
   { get_allocator().construct(&__tmp->_M_value_field, __x); }
 catch(...)
   {
     _M_put_node(__tmp);
     throw;
   }
 return __tmp;
      }

      void
      _M_destroy_node(_Link_type __p)
      {
 get_allocator().destroy(&__p->_M_value_field);
 _M_put_node(__p);
      }
# 413 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
      _Link_type
      _M_clone_node(_Const_Link_type __x)
      {
 _Link_type __tmp = _M_create_node(__x->_M_value_field);
 __tmp->_M_color = __x->_M_color;
 __tmp->_M_left = 0;
 __tmp->_M_right = 0;
 return __tmp;
      }

    protected:
      template<typename _Key_compare,
        bool _Is_pod_comparator = __is_pod(_Key_compare)>
        struct _Rb_tree_impl : public _Node_allocator
        {
   _Key_compare _M_key_compare;
   _Rb_tree_node_base _M_header;
   size_type _M_node_count;

   _Rb_tree_impl()
   : _Node_allocator(), _M_key_compare(), _M_header(),
     _M_node_count(0)
   { _M_initialize(); }

   _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
   : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
     _M_node_count(0)
   { _M_initialize(); }

 private:
   void
   _M_initialize()
   {
     this->_M_header._M_color = _S_red;
     this->_M_header._M_parent = 0;
     this->_M_header._M_left = &this->_M_header;
     this->_M_header._M_right = &this->_M_header;
   }
 };

      _Rb_tree_impl<_Compare> _M_impl;

    protected:
      _Base_ptr&
      _M_root()
      { return this->_M_impl._M_header._M_parent; }

      _Const_Base_ptr
      _M_root() const
      { return this->_M_impl._M_header._M_parent; }

      _Base_ptr&
      _M_leftmost()
      { return this->_M_impl._M_header._M_left; }

      _Const_Base_ptr
      _M_leftmost() const
      { return this->_M_impl._M_header._M_left; }

      _Base_ptr&
      _M_rightmost()
      { return this->_M_impl._M_header._M_right; }

      _Const_Base_ptr
      _M_rightmost() const
      { return this->_M_impl._M_header._M_right; }

      _Link_type
      _M_begin()
      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }

      _Const_Link_type
      _M_begin() const
      {
 return static_cast<_Const_Link_type>
   (this->_M_impl._M_header._M_parent);
      }

      _Link_type
      _M_end()
      { return static_cast<_Link_type>(&this->_M_impl._M_header); }

      _Const_Link_type
      _M_end() const
      { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }

      static const_reference
      _S_value(_Const_Link_type __x)
      { return __x->_M_value_field; }

      static const _Key&
      _S_key(_Const_Link_type __x)
      { return _KeyOfValue()(_S_value(__x)); }

      static _Link_type
      _S_left(_Base_ptr __x)
      { return static_cast<_Link_type>(__x->_M_left); }

      static _Const_Link_type
      _S_left(_Const_Base_ptr __x)
      { return static_cast<_Const_Link_type>(__x->_M_left); }

      static _Link_type
      _S_right(_Base_ptr __x)
      { return static_cast<_Link_type>(__x->_M_right); }

      static _Const_Link_type
      _S_right(_Const_Base_ptr __x)
      { return static_cast<_Const_Link_type>(__x->_M_right); }

      static const_reference
      _S_value(_Const_Base_ptr __x)
      { return static_cast<_Const_Link_type>(__x)->_M_value_field; }

      static const _Key&
      _S_key(_Const_Base_ptr __x)
      { return _KeyOfValue()(_S_value(__x)); }

      static _Base_ptr
      _S_minimum(_Base_ptr __x)
      { return _Rb_tree_node_base::_S_minimum(__x); }

      static _Const_Base_ptr
      _S_minimum(_Const_Base_ptr __x)
      { return _Rb_tree_node_base::_S_minimum(__x); }

      static _Base_ptr
      _S_maximum(_Base_ptr __x)
      { return _Rb_tree_node_base::_S_maximum(__x); }

      static _Const_Base_ptr
      _S_maximum(_Const_Base_ptr __x)
      { return _Rb_tree_node_base::_S_maximum(__x); }

    public:
      typedef _Rb_tree_iterator<value_type> iterator;
      typedef _Rb_tree_const_iterator<value_type> const_iterator;

      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    private:
      iterator
      _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __y,
   const value_type& __v);



      iterator
      _M_insert_lower(_Base_ptr __x, _Base_ptr __y, const value_type& __v);

      iterator
      _M_insert_equal_lower(const value_type& __x);

      _Link_type
      _M_copy(_Const_Link_type __x, _Link_type __p);

      void
      _M_erase(_Link_type __x);

      iterator
      _M_lower_bound(_Link_type __x, _Link_type __y,
       const _Key& __k);

      const_iterator
      _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
       const _Key& __k) const;

      iterator
      _M_upper_bound(_Link_type __x, _Link_type __y,
       const _Key& __k);

      const_iterator
      _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
       const _Key& __k) const;

    public:

      _Rb_tree() { }

      _Rb_tree(const _Compare& __comp,
        const allocator_type& __a = allocator_type())
      : _M_impl(__comp, __a) { }

      _Rb_tree(const _Rb_tree& __x)
      : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
      {
 if (__x._M_root() != 0)
   {
     _M_root() = _M_copy(__x._M_begin(), _M_end());
     _M_leftmost() = _S_minimum(_M_root());
     _M_rightmost() = _S_maximum(_M_root());
     _M_impl._M_node_count = __x._M_impl._M_node_count;
   }
      }





      ~_Rb_tree()
      { _M_erase(_M_begin()); }

      _Rb_tree&
      operator=(const _Rb_tree& __x);


      _Compare
      key_comp() const
      { return _M_impl._M_key_compare; }

      iterator
      begin()
      {
 return iterator(static_cast<_Link_type>
   (this->_M_impl._M_header._M_left));
      }

      const_iterator
      begin() const
      {
 return const_iterator(static_cast<_Const_Link_type>
         (this->_M_impl._M_header._M_left));
      }

      iterator
      end()
      { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }

      const_iterator
      end() const
      {
 return const_iterator(static_cast<_Const_Link_type>
         (&this->_M_impl._M_header));
      }

      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()); }

      bool
      empty() const
      { return _M_impl._M_node_count == 0; }

      size_type
      size() const
      { return _M_impl._M_node_count; }

      size_type
      max_size() const
      { return _M_get_Node_allocator().max_size(); }

      void
      swap(_Rb_tree& __t);


      pair<iterator, bool>
      _M_insert_unique(const value_type& __x);

      iterator
      _M_insert_equal(const value_type& __x);

      iterator
      _M_insert_unique_(const_iterator __position, const value_type& __x);

      iterator
      _M_insert_equal_(const_iterator __position, const value_type& __x);

      template<typename _InputIterator>
        void
        _M_insert_unique(_InputIterator __first, _InputIterator __last);

      template<typename _InputIterator>
        void
        _M_insert_equal(_InputIterator __first, _InputIterator __last);
# 712 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
      void
      erase(iterator __position);

      void
      erase(const_iterator __position);

      size_type
      erase(const key_type& __x);
# 732 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
      void
      erase(iterator __first, iterator __last);

      void
      erase(const_iterator __first, const_iterator __last);

      void
      erase(const key_type* __first, const key_type* __last);

      void
      clear()
      {
        _M_erase(_M_begin());
        _M_leftmost() = _M_end();
        _M_root() = 0;
        _M_rightmost() = _M_end();
        _M_impl._M_node_count = 0;
      }


      iterator
      find(const key_type& __k);

      const_iterator
      find(const key_type& __k) const;

      size_type
      count(const key_type& __k) const;

      iterator
      lower_bound(const key_type& __k)
      { return _M_lower_bound(_M_begin(), _M_end(), __k); }

      const_iterator
      lower_bound(const key_type& __k) const
      { return _M_lower_bound(_M_begin(), _M_end(), __k); }

      iterator
      upper_bound(const key_type& __k)
      { return _M_upper_bound(_M_begin(), _M_end(), __k); }

      const_iterator
      upper_bound(const key_type& __k) const
      { return _M_upper_bound(_M_begin(), _M_end(), __k); }

      pair<iterator, iterator>
      equal_range(const key_type& __k);

      pair<const_iterator, const_iterator>
      equal_range(const key_type& __k) const;


      bool
      __rb_verify() const;
    };

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    {
      return __x.size() == __y.size()
      && std::equal(__x.begin(), __x.end(), __y.begin());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    {
      return std::lexicographical_compare(__x.begin(), __x.end(),
       __y.begin(), __y.end());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return !(__x == __y); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return __y < __x; }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return !(__y < __x); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return !(__x < __y); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline void
    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { __x.swap(__y); }
# 867 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
    {
      if (this != &__x)
 {

   clear();
   _M_impl._M_key_compare = __x._M_impl._M_key_compare;
   if (__x._M_root() != 0)
     {
       _M_root() = _M_copy(__x._M_begin(), _M_end());
       _M_leftmost() = _S_minimum(_M_root());
       _M_rightmost() = _S_maximum(_M_root());
       _M_impl._M_node_count = __x._M_impl._M_node_count;
     }
 }
      return *this;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __p, const _Val& __v)
    {
      bool __insert_left = (__x != 0 || __p == _M_end()
       || _M_impl._M_key_compare(_KeyOfValue()(__v),
            _S_key(__p)));

      _Link_type __z = _M_create_node(__v);

      _Rb_tree_insert_and_rebalance(__insert_left, __z,
        const_cast<_Base_ptr>(__p),
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_lower(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
    {
      bool __insert_left = (__x != 0 || __p == _M_end()
       || !_M_impl._M_key_compare(_S_key(__p),
             _KeyOfValue()(__v)));

      _Link_type __z = _M_create_node(__v);

      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_equal_lower(const _Val& __v)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
         _S_left(__x) : _S_right(__x);
 }
      return _M_insert_lower(__x, __y, __v);
    }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
    _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
    _M_copy(_Const_Link_type __x, _Link_type __p)
    {

      _Link_type __top = _M_clone_node(__x);
      __top->_M_parent = __p;

      try
 {
   if (__x->_M_right)
     __top->_M_right = _M_copy(_S_right(__x), __top);
   __p = __top;
   __x = _S_left(__x);

   while (__x != 0)
     {
       _Link_type __y = _M_clone_node(__x);
       __p->_M_left = __y;
       __y->_M_parent = __p;
       if (__x->_M_right)
  __y->_M_right = _M_copy(_S_right(__x), __y);
       __p = __y;
       __x = _S_left(__x);
     }
 }
      catch(...)
 {
   _M_erase(__top);
   throw;
 }
      return __top;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_erase(_Link_type __x)
    {

      while (__x != 0)
 {
   _M_erase(_S_right(__x));
   _Link_type __y = _S_left(__x);
   _M_destroy_node(__x);
   __x = __y;
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_lower_bound(_Link_type __x, _Link_type __y,
     const _Key& __k)
    {
      while (__x != 0)
 if (!_M_impl._M_key_compare(_S_key(__x), __k))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
     const _Key& __k) const
    {
      while (__x != 0)
 if (!_M_impl._M_key_compare(_S_key(__x), __k))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return const_iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_upper_bound(_Link_type __x, _Link_type __y,
     const _Key& __k)
    {
      while (__x != 0)
 if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
     const _Key& __k) const
    {
      while (__x != 0)
 if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return const_iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    equal_range(const _Key& __k)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      while (__x != 0)
 {
   if (_M_impl._M_key_compare(_S_key(__x), __k))
     __x = _S_right(__x);
   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
     __y = __x, __x = _S_left(__x);
   else
     {
       _Link_type __xu(__x), __yu(__y);
       __y = __x, __x = _S_left(__x);
       __xu = _S_right(__xu);
       return pair<iterator,
            iterator>(_M_lower_bound(__x, __y, __k),
        _M_upper_bound(__xu, __yu, __k));
     }
 }
      return pair<iterator, iterator>(iterator(__y),
          iterator(__y));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    equal_range(const _Key& __k) const
    {
      _Const_Link_type __x = _M_begin();
      _Const_Link_type __y = _M_end();
      while (__x != 0)
 {
   if (_M_impl._M_key_compare(_S_key(__x), __k))
     __x = _S_right(__x);
   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
     __y = __x, __x = _S_left(__x);
   else
     {
       _Const_Link_type __xu(__x), __yu(__y);
       __y = __x, __x = _S_left(__x);
       __xu = _S_right(__xu);
       return pair<const_iterator,
            const_iterator>(_M_lower_bound(__x, __y, __k),
       _M_upper_bound(__xu, __yu, __k));
     }
 }
      return pair<const_iterator, const_iterator>(const_iterator(__y),
        const_iterator(__y));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
    {
      if (_M_root() == 0)
 {
   if (__t._M_root() != 0)
     {
       _M_root() = __t._M_root();
       _M_leftmost() = __t._M_leftmost();
       _M_rightmost() = __t._M_rightmost();
       _M_root()->_M_parent = _M_end();

       __t._M_root() = 0;
       __t._M_leftmost() = __t._M_end();
       __t._M_rightmost() = __t._M_end();
     }
 }
      else if (__t._M_root() == 0)
 {
   __t._M_root() = _M_root();
   __t._M_leftmost() = _M_leftmost();
   __t._M_rightmost() = _M_rightmost();
   __t._M_root()->_M_parent = __t._M_end();

   _M_root() = 0;
   _M_leftmost() = _M_end();
   _M_rightmost() = _M_end();
 }
      else
 {
   std::swap(_M_root(),__t._M_root());
   std::swap(_M_leftmost(),__t._M_leftmost());
   std::swap(_M_rightmost(),__t._M_rightmost());

   _M_root()->_M_parent = _M_end();
   __t._M_root()->_M_parent = __t._M_end();
 }

      std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
      std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);



      std::__alloc_swap<_Node_allocator>::
 _S_do_it(_M_get_Node_allocator(), __t._M_get_Node_allocator());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator, bool>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_unique(const _Val& __v)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      bool __comp = true;
      while (__x != 0)
 {
   __y = __x;
   __comp = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x));
   __x = __comp ? _S_left(__x) : _S_right(__x);
 }
      iterator __j = iterator(__y);
      if (__comp)
 {
   if (__j == begin())
     return pair<iterator, bool>(_M_insert_(__x, __y, __v), true);
   else
     --__j;
 }
      if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
 return pair<iterator, bool>(_M_insert_(__x, __y, __v), true);
      return pair<iterator, bool>(__j, false);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_equal(const _Val& __v)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
         _S_left(__x) : _S_right(__x);
 }
      return _M_insert_(__x, __y, __v);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_unique_(const_iterator __position, const _Val& __v)
    {

      if (__position._M_node == _M_end())
 {
   if (size() > 0
       && _M_impl._M_key_compare(_S_key(_M_rightmost()),
     _KeyOfValue()(__v)))
     return _M_insert_(0, _M_rightmost(), __v);
   else
     return _M_insert_unique(__v).first;
 }
      else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
          _S_key(__position._M_node)))
 {

   const_iterator __before = __position;
   if (__position._M_node == _M_leftmost())
     return _M_insert_(_M_leftmost(), _M_leftmost(), __v);
   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node),
       _KeyOfValue()(__v)))
     {
       if (_S_right(__before._M_node) == 0)
  return _M_insert_(0, __before._M_node, __v);
       else
  return _M_insert_(__position._M_node,
      __position._M_node, __v);
     }
   else
     return _M_insert_unique(__v).first;
 }
      else if (_M_impl._M_key_compare(_S_key(__position._M_node),
          _KeyOfValue()(__v)))
 {

   const_iterator __after = __position;
   if (__position._M_node == _M_rightmost())
     return _M_insert_(0, _M_rightmost(), __v);
   else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
       _S_key((++__after)._M_node)))
     {
       if (_S_right(__position._M_node) == 0)
  return _M_insert_(0, __position._M_node, __v);
       else
  return _M_insert_(__after._M_node, __after._M_node, __v);
     }
   else
     return _M_insert_unique(__v).first;
 }
      else

 return iterator(static_cast<_Link_type>
   (const_cast<_Base_ptr>(__position._M_node)));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_equal_(const_iterator __position, const _Val& __v)
    {

      if (__position._M_node == _M_end())
 {
   if (size() > 0
       && !_M_impl._M_key_compare(_KeyOfValue()(__v),
      _S_key(_M_rightmost())))
     return _M_insert_(0, _M_rightmost(), __v);
   else
     return _M_insert_equal(__v);
 }
      else if (!_M_impl._M_key_compare(_S_key(__position._M_node),
           _KeyOfValue()(__v)))
 {

   const_iterator __before = __position;
   if (__position._M_node == _M_leftmost())
     return _M_insert_(_M_leftmost(), _M_leftmost(), __v);
   else if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
        _S_key((--__before)._M_node)))
     {
       if (_S_right(__before._M_node) == 0)
  return _M_insert_(0, __before._M_node, __v);
       else
  return _M_insert_(__position._M_node,
      __position._M_node, __v);
     }
   else
     return _M_insert_equal(__v);
 }
      else
 {

   const_iterator __after = __position;
   if (__position._M_node == _M_rightmost())
     return _M_insert_(0, _M_rightmost(), __v);
   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node),
        _KeyOfValue()(__v)))
     {
       if (_S_right(__position._M_node) == 0)
  return _M_insert_(0, __position._M_node, __v);
       else
  return _M_insert_(__after._M_node, __after._M_node, __v);
     }
   else
     return _M_insert_equal_lower(__v);
 }
    }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Cmp, typename _Alloc>
    template<class _II>
      void
      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
      _M_insert_unique(_II __first, _II __last)
      {
 for (; __first != __last; ++__first)
   _M_insert_unique_(end(), *__first);
      }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Cmp, typename _Alloc>
    template<class _II>
      void
      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
      _M_insert_equal(_II __first, _II __last)
      {
 for (; __first != __last; ++__first)
   _M_insert_equal_(end(), *__first);
      }
# 1391 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(iterator __position)
    {
      _Link_type __y =
 static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
    (__position._M_node,
     this->_M_impl._M_header));
      _M_destroy_node(__y);
      --_M_impl._M_node_count;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(const_iterator __position)
    {
      _Link_type __y =
 static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
    (const_cast<_Base_ptr>(__position._M_node),
     this->_M_impl._M_header));
      _M_destroy_node(__y);
      --_M_impl._M_node_count;
    }


  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(const _Key& __x)
    {
      pair<iterator, iterator> __p = equal_range(__x);
      const size_type __old_size = size();
      erase(__p.first, __p.second);
      return __old_size - size();
    }
# 1475 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(iterator __first, iterator __last)
    {
      if (__first == begin() && __last == end())
 clear();
      else
 while (__first != __last)
   erase(__first++);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(const_iterator __first, const_iterator __last)
    {
      if (__first == begin() && __last == end())
 clear();
      else
 while (__first != __last)
   erase(__first++);
    }


  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(const _Key* __first, const _Key* __last)
    {
      while (__first != __last)
 erase(*__first++);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    find(const _Key& __k)
    {
      iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
      return (__j == end()
       || _M_impl._M_key_compare(__k,
     _S_key(__j._M_node))) ? end() : __j;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    find(const _Key& __k) const
    {
      const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
      return (__j == end()
       || _M_impl._M_key_compare(__k,
     _S_key(__j._M_node))) ? end() : __j;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    count(const _Key& __k) const
    {
      pair<const_iterator, const_iterator> __p = equal_range(__k);
      const size_type __n = std::distance(__p.first, __p.second);
      return __n;
    }

  __attribute__ ((__pure__)) unsigned int
  _Rb_tree_black_count(const _Rb_tree_node_base* __node,
                       const _Rb_tree_node_base* __root) throw ();

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    bool
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
    {
      if (_M_impl._M_node_count == 0 || begin() == end())
 return _M_impl._M_node_count == 0 && begin() == end()
        && this->_M_impl._M_header._M_left == _M_end()
        && this->_M_impl._M_header._M_right == _M_end();

      unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
      for (const_iterator __it = begin(); __it != end(); ++__it)
 {
   _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
   _Const_Link_type __L = _S_left(__x);
   _Const_Link_type __R = _S_right(__x);

   if (__x->_M_color == _S_red)
     if ((__L && __L->_M_color == _S_red)
  || (__R && __R->_M_color == _S_red))
       return false;

   if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
     return false;
   if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
     return false;

   if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
     return false;
 }

      if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
 return false;
      if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
 return false;
      return true;
    }

}
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 1 3
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 84 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
  template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
            typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
    class map
    {
    public:
      typedef _Key key_type;
      typedef _Tp mapped_type;
      typedef std::pair<const _Key, _Tp> value_type;
      typedef _Compare key_compare;
      typedef _Alloc allocator_type;

    private:

      typedef typename _Alloc::value_type _Alloc_value_type;
     
     

     

    public:
      class value_compare
      : public std::binary_function<value_type, value_type, bool>
      {
 friend class map<_Key, _Tp, _Compare, _Alloc>;
      protected:
 _Compare comp;

 value_compare(_Compare __c)
 : comp(__c) { }

      public:
 bool operator()(const value_type& __x, const value_type& __y) const
 { return comp(__x.first, __y.first); }
      };

    private:

      typedef typename _Alloc::template rebind<value_type>::other
        _Pair_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
         key_compare, _Pair_alloc_type> _Rep_type;


      _Rep_type _M_t;

    public:


      typedef typename _Pair_alloc_type::pointer pointer;
      typedef typename _Pair_alloc_type::const_pointer const_pointer;
      typedef typename _Pair_alloc_type::reference reference;
      typedef typename _Pair_alloc_type::const_reference const_reference;
      typedef typename _Rep_type::iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;
      typedef typename _Rep_type::reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;







      map()
      : _M_t() { }






      explicit
      map(const _Compare& __comp,
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, __a) { }
# 170 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      map(const map& __x)
      : _M_t(__x._M_t) { }
# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      template<typename _InputIterator>
        map(_InputIterator __first, _InputIterator __last)
 : _M_t()
        { _M_t._M_insert_unique(__first, __last); }
# 227 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      template<typename _InputIterator>
        map(_InputIterator __first, _InputIterator __last,
     const _Compare& __comp,
     const allocator_type& __a = allocator_type())
 : _M_t(__comp, __a)
        { _M_t._M_insert_unique(__first, __last); }
# 250 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      map&
      operator=(const map& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      allocator_type
      get_allocator() const
      { return _M_t.get_allocator(); }







      iterator
      begin()
      { return _M_t.begin(); }






      const_iterator
      begin() const
      { return _M_t.begin(); }






      iterator
      end()
      { return _M_t.end(); }






      const_iterator
      end() const
      { return _M_t.end(); }






      reverse_iterator
      rbegin()
      { return _M_t.rbegin(); }






      const_reverse_iterator
      rbegin() const
      { return _M_t.rbegin(); }






      reverse_iterator
      rend()
      { return _M_t.rend(); }






      const_reverse_iterator
      rend() const
      { return _M_t.rend(); }
# 415 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      bool
      empty() const
      { return _M_t.empty(); }


      size_type
      size() const
      { return _M_t.size(); }


      size_type
      max_size() const
      { return _M_t.max_size(); }
# 442 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      mapped_type&
      operator[](const key_type& __k)
      {



 iterator __i = lower_bound(__k);

 if (__i == end() || key_comp()(__k, (*__i).first))
          __i = insert(__i, value_type(__k, mapped_type()));
 return (*__i).second;
      }
# 464 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      mapped_type&
      at(const key_type& __k)
      {
 iterator __i = lower_bound(__k);
 if (__i == end() || key_comp()(__k, (*__i).first))
   __throw_out_of_range(("map::at"));
 return (*__i).second;
      }

      const mapped_type&
      at(const key_type& __k) const
      {
 const_iterator __i = lower_bound(__k);
 if (__i == end() || key_comp()(__k, (*__i).first))
   __throw_out_of_range(("map::at"));
 return (*__i).second;
      }
# 499 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_t._M_insert_unique(__x); }
# 539 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      iterator
      insert(iterator __position, const value_type& __x)
      { return _M_t._M_insert_unique_(__position, __x); }
# 551 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      template<typename _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t._M_insert_unique(__first, __last); }
# 586 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 602 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 636 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 652 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      void
      swap(map& __x)
      { _M_t.swap(__x._M_t); }







      void
      clear()
      { _M_t.clear(); }






      key_compare
      key_comp() const
      { return _M_t.key_comp(); }





      value_compare
      value_comp() const
      { return value_compare(_M_t.key_comp()); }
# 695 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }
# 710 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }
# 722 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
# 737 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }
# 752 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }







      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }







      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }
# 791 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }
# 810 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }

      template<typename _K1, typename _T1, typename _C1, typename _A1>
        friend bool
        operator==(const map<_K1, _T1, _C1, _A1>&,
     const map<_K1, _T1, _C1, _A1>&);

      template<typename _K1, typename _T1, typename _C1, typename _A1>
        friend bool
        operator<(const map<_K1, _T1, _C1, _A1>&,
    const map<_K1, _T1, _C1, _A1>&);
    };
# 835 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
               const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 852 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
              const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
               const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
              const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
               const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
               const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline void
    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
  map<_Key, _Tp, _Compare, _Alloc>& __y)
    { __x.swap(__y); }

}
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 1 3
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
  template <typename _Key, typename _Tp,
     typename _Compare = std::less<_Key>,
     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
    class multimap
    {
    public:
      typedef _Key key_type;
      typedef _Tp mapped_type;
      typedef std::pair<const _Key, _Tp> value_type;
      typedef _Compare key_compare;
      typedef _Alloc allocator_type;

    private:

      typedef typename _Alloc::value_type _Alloc_value_type;
     
     

     

    public:
      class value_compare
      : public std::binary_function<value_type, value_type, bool>
      {
 friend class multimap<_Key, _Tp, _Compare, _Alloc>;
      protected:
 _Compare comp;

 value_compare(_Compare __c)
 : comp(__c) { }

      public:
 bool operator()(const value_type& __x, const value_type& __y) const
 { return comp(__x.first, __y.first); }
      };

    private:

      typedef typename _Alloc::template rebind<value_type>::other
        _Pair_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
         key_compare, _Pair_alloc_type> _Rep_type;

      _Rep_type _M_t;

    public:


      typedef typename _Pair_alloc_type::pointer pointer;
      typedef typename _Pair_alloc_type::const_pointer const_pointer;
      typedef typename _Pair_alloc_type::reference reference;
      typedef typename _Pair_alloc_type::const_reference const_reference;
      typedef typename _Rep_type::iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;
      typedef typename _Rep_type::reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;






      multimap()
      : _M_t() { }






      explicit
      multimap(const _Compare& __comp,
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, __a) { }
# 168 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      multimap(const multimap& __x)
      : _M_t(__x._M_t) { }
# 208 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      template<typename _InputIterator>
        multimap(_InputIterator __first, _InputIterator __last)
 : _M_t()
        { _M_t._M_insert_equal(__first, __last); }
# 224 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      template<typename _InputIterator>
        multimap(_InputIterator __first, _InputIterator __last,
   const _Compare& __comp,
   const allocator_type& __a = allocator_type())
        : _M_t(__comp, __a)
        { _M_t._M_insert_equal(__first, __last); }
# 247 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      multimap&
      operator=(const multimap& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      allocator_type
      get_allocator() const
      { return _M_t.get_allocator(); }







      iterator
      begin()
      { return _M_t.begin(); }






      const_iterator
      begin() const
      { return _M_t.begin(); }






      iterator
      end()
      { return _M_t.end(); }






      const_iterator
      end() const
      { return _M_t.end(); }






      reverse_iterator
      rbegin()
      { return _M_t.rbegin(); }






      const_reverse_iterator
      rbegin() const
      { return _M_t.rbegin(); }






      reverse_iterator
      rend()
      { return _M_t.rend(); }






      const_reverse_iterator
      rend() const
      { return _M_t.rend(); }
# 410 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      bool
      empty() const
      { return _M_t.empty(); }


      size_type
      size() const
      { return _M_t.size(); }


      size_type
      max_size() const
      { return _M_t.max_size(); }
# 437 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__x); }
# 461 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      iterator
      insert(iterator __position, const value_type& __x)
      { return _M_t._M_insert_equal_(__position, __x); }
# 474 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      template<typename _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t._M_insert_equal(__first, __last); }
# 522 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 538 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 574 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 590 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      void
      swap(multimap& __x)
      { _M_t.swap(__x._M_t); }







      void
      clear()
      { _M_t.clear(); }






      key_compare
      key_comp() const
      { return _M_t.key_comp(); }





      value_compare
      value_comp() const
      { return value_compare(_M_t.key_comp()); }
# 633 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }
# 648 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }






      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }
# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }
# 687 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }







      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }







      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }
# 724 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }
# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }

      template<typename _K1, typename _T1, typename _C1, typename _A1>
        friend bool
        operator==(const multimap<_K1, _T1, _C1, _A1>&,
     const multimap<_K1, _T1, _C1, _A1>&);

      template<typename _K1, typename _T1, typename _C1, typename _A1>
        friend bool
        operator<(const multimap<_K1, _T1, _C1, _A1>&,
    const multimap<_K1, _T1, _C1, _A1>&);
  };
# 766 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 783 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline void
    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
         multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { __x.swap(__y); }

}
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 2 3
# 17 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iostream" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iostream" 3
       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iostream" 3





namespace std __attribute__ ((__visibility__ ("default"))) {
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iostream" 3
  extern istream cin;
  extern ostream cout;
  extern ostream cerr;
  extern ostream clog;


  extern wistream wcin;
  extern wostream wcout;
  extern wostream wcerr;
  extern wostream wclog;




  static ios_base::Init __ioinit;

}
# 18 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 2

namespace boost { namespace python { namespace detail {







    template <class Proxy>
    struct compare_proxy_index
    {




        template <class Index>
        bool operator()(PyObject* prox, Index i) const
        {
            typedef typename Proxy::policies_type policies_type;
            Proxy& proxy = extract<Proxy&>(prox)();
            return policies_type::
                compare_index(proxy.get_container(), proxy.get_index(), i);
        }
    };
# 53 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp"
    template <class Proxy>
    class proxy_group
    {
    public:

        typedef typename std::vector<PyObject*>::const_iterator const_iterator;
        typedef typename std::vector<PyObject*>::iterator iterator;
        typedef typename Proxy::index_type index_type;
        typedef typename Proxy::policies_type policies_type;

        iterator
        first_proxy(index_type i)
        {

            return boost::detail::lower_bound(
                proxies.begin(), proxies.end(),
                i, compare_proxy_index<Proxy>());
        }

        void
        remove(Proxy& proxy)
        {

            for (iterator iter = first_proxy(proxy.get_index());
                iter != proxies.end(); ++iter)
            {
                if (&extract<Proxy&>(*iter)() == &proxy)
                {
                    proxies.erase(iter);
                    break;
                }
            }
            ;
        }

        void
        add(PyObject* prox)
        {
            ;

            proxies.insert(
                first_proxy(extract<Proxy&>(prox)().get_index()), prox);
            ;
        }

        void
        erase(index_type i, mpl::false_)
        {
            ;

            replace(i, i+1, 0);
            ;
        }

        void
        erase(index_type i, mpl::true_)
        {
            ;


            iterator iter = first_proxy(i);
            extract<Proxy&> p(*iter);

            if (iter != proxies.end() && p().get_index() == i)
            {
                extract<Proxy&> p(*iter);
                p().detach();
                proxies.erase(iter);
            }
            ;
        }

        void
        erase(index_type from, index_type to)
        {


            ;

            replace(from, to, 0);
            ;
        }

        void
        replace(
            index_type from,
            index_type to,
            typename std::vector<PyObject*>::size_type len)
        {


            ;







            iterator left = first_proxy(from);
            iterator right = proxies.end();

            for (iterator iter = left; iter != right; ++iter)
            {
                if (extract<Proxy&>(*iter)().get_index() > to)
                {
                    right = iter;
                    break;
                }
                extract<Proxy&> p(*iter);
                p().detach();
            }

            typename std::vector<PyObject*>::size_type
                offset = left-proxies.begin();
            proxies.erase(left, right);
            right = proxies.begin()+offset;

            while (right != proxies.end())
            {
                typedef typename Proxy::container_type::difference_type difference_type;
                extract<Proxy&> p(*right);
                p().set_index(
                    extract<Proxy&>(*right)().get_index()
                    - (difference_type(to) - from - len)
                );

                ++right;
            }
            ;
        }

        PyObject*
        find(index_type i)
        {
            ;



            iterator iter = first_proxy(i);
            if (iter != proxies.end()
                && extract<Proxy&>(*iter)().get_index() == i)
            {
                ;
                return *iter;
            }
            ;
            return 0;
        }

        typename std::vector<PyObject*>::size_type
        size() const
        {
            ;

            return proxies.size();
        }

    private:
# 240 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp"
        std::vector<PyObject*> proxies;
    };






    template <class Proxy, class Container>
    class proxy_links
    {
    public:

        typedef std::map<Container*, proxy_group<Proxy> > links_t;
        typedef typename Proxy::index_type index_type;

        void
        remove(Proxy& proxy)
        {

            typename links_t::iterator r = links.find(&proxy.get_container());
            if (r != links.end())
            {
                r->second.remove(proxy);
                if (r->second.size() == 0)
                    links.erase(r);
            }
        }

        void
        add(PyObject* prox, Container& container)
        {

            links[&container].add(prox);
        }

        template <class NoSlice>
        void erase(Container& container, index_type i, NoSlice no_slice)
        {

            typename links_t::iterator r = links.find(&container);
            if (r != links.end())
            {
                r->second.erase(i, no_slice);
                if (r->second.size() == 0)
                    links.erase(r);
            }
        }

        void
        erase(Container& container, index_type from, index_type to)
        {

            typename links_t::iterator r = links.find(&container);
            if (r != links.end())
            {
                r->second.erase(from, to);
                if (r->second.size() == 0)
                    links.erase(r);
            }
        }

        void
        replace(
            Container& container,
            index_type from, index_type to, index_type len)
        {







            typename links_t::iterator r = links.find(&container);
            if (r != links.end())
            {
                r->second.replace(from, to, len);
                if (r->second.size() == 0)
                    links.erase(r);
            }
        }

        PyObject*
        find(Container& container, index_type i)
        {



            typename links_t::iterator r = links.find(&container);
            if (r != links.end())
                return r->second.find(i);
            return 0;
        }

    private:

        links_t links;
    };
# 351 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp"
    template <class Container, class Index, class Policies>
    class container_element
    {
    public:

        typedef Index index_type;
        typedef Container container_type;
        typedef typename Policies::data_type element_type;
        typedef Policies policies_type;
        typedef container_element<Container, Index, Policies> self_t;
        typedef proxy_group<self_t> links_type;

        container_element(object container, Index index)
            : ptr()
            , container(container)
            , index(index)
        {
        }

        container_element(container_element const& ce)
          : ptr(ce.ptr.get() == 0 ? 0 : new element_type(*ce.ptr.get()))
          , container(ce.container)
          , index(ce.index)
        {
        }

        ~container_element()
        {
            if (!is_detached())
                get_links().remove(*this);
        }

        element_type& operator*() const
        {
            if (is_detached())
                return *get_pointer(ptr);
            return Policies::get_item(get_container(), index);
        }

        element_type* get() const
        {
            if (is_detached())
                return get_pointer(ptr);
            return &Policies::get_item(get_container(), index);
        }

        void
        detach()
        {
            if (!is_detached())
            {
                ptr.reset(
                    new element_type(
                        Policies::get_item(get_container(), index)));
                container = object();
            }
        }

        bool
        is_detached() const
        {
            return get_pointer(ptr) != 0;
        }

        Container&
        get_container() const
        {
            return extract<Container&>(container)();
        }

        Index
        get_index() const
        {
            return index;
        }

        void
        set_index(Index i)
        {
            index = i;
        }

        static proxy_links<self_t, Container>&
        get_links()
        {




            static proxy_links<self_t, Container> links;
            return links;
        }

    private:

        container_element& operator=(container_element const& ce);

        scoped_ptr<element_type> ptr;
        object container;
        Index index;
    };

    template <
          class Container
        , class DerivedPolicies
        , class ContainerElement
        , class Index
    >
    struct no_proxy_helper
    {
        static void
        register_container_element()
        {
        }

        template <class DataType>
        static object
        base_get_item_helper(DataType const& p, mpl::true_)
        {
            return object(ptr(p));
        }

        template <class DataType>
        static object
        base_get_item_helper(DataType const& x, mpl::false_)
        {
            return object(x);
        }

        static object
        base_get_item_(back_reference<Container&> const& container, PyObject* i)
        {
            return base_get_item_helper(
                DerivedPolicies::get_item(
                    container.get(), DerivedPolicies::
                        convert_index(container.get(), i))
              , is_pointer<typename Container::value_type>()
            );
        }

        static void
        base_replace_indexes(
            Container& , Index ,
            Index , Index )
        {
        }

        template <class NoSlice>
        static void
        base_erase_index(
            Container& , Index , NoSlice )
        {
        }

        static void
        base_erase_indexes(Container& , Index , Index )
        {
        }
    };

    template <
          class Container
        , class DerivedPolicies
        , class ContainerElement
        , class Index
    >
    struct proxy_helper
    {
        static void
        register_container_element()
        {
            register_ptr_to_python<ContainerElement>();
        }

        static object
        base_get_item_(back_reference<Container&> const& container, PyObject* i)
        {

            Index idx = DerivedPolicies::convert_index(container.get(), i);

            if (PyObject* shared =
                ContainerElement::get_links().find(container.get(), idx))
            {
                handle<> h(python::borrowed(shared));
                return object(h);
            }
            else
            {
                object prox(ContainerElement(container.source(), idx));
                ContainerElement::
                    get_links().add(prox.ptr(), container.get());
                return prox;
            }
        }

        static void
        base_replace_indexes(
            Container& container, Index from,
            Index to, Index n)
        {
            ContainerElement::get_links().replace(container, from, to, n);
        }

        template <class NoSlice>
        static void
        base_erase_index(
            Container& container, Index i, NoSlice no_slice)
        {
            ContainerElement::get_links().erase(container, i, no_slice);
        }

        static void
        base_erase_indexes(
            Container& container, Index from, Index to)
        {
            ContainerElement::get_links().erase(container, from, to);
        }
    };

    template <
          class Container
        , class DerivedPolicies
        , class ProxyHandler
        , class Data
        , class Index
    >
    struct slice_helper
    {
        static object
        base_get_slice(Container& container, PySliceObject* slice)
        {
            Index from, to;
            base_get_slice_data(container, slice, from, to);
            return DerivedPolicies::get_slice(container, from, to);
        }

        static void
        base_get_slice_data(
            Container& container, PySliceObject* slice, Index& from_, Index& to_)
        {
            if ((&_Py_NoneStruct) != slice->step) {
                PyErr_SetString( PyExc_IndexError, "slice step size not supported.");
                throw_error_already_set();
            }

            Index min_index = DerivedPolicies::get_min_index(container);
            Index max_index = DerivedPolicies::get_max_index(container);

            if ((&_Py_NoneStruct) == slice->start) {
                from_ = min_index;
            }
            else {
                long from = extract<long>( slice->start);
                if (from < 0)
                    from += max_index;
                if (from < 0)
                    from = 0;
                from_ = boost::numeric_cast<Index>(from);
                if (from_ > max_index)
                    from_ = max_index;
            }

            if ((&_Py_NoneStruct) == slice->stop) {
                to_ = max_index;
            }
            else {
                long to = extract<long>( slice->stop);
                if (to < 0)
                    to += max_index;
                if (to < 0)
                    to = 0;
                to_ = boost::numeric_cast<Index>(to);
                if (to_ > max_index)
                    to_ = max_index;
            }
        }

        static void
        base_set_slice(Container& container, PySliceObject* slice, PyObject* v)
        {
            Index from, to;
            base_get_slice_data(container, slice, from, to);

            extract<Data&> elem(v);

            if (elem.check())
            {
                ProxyHandler::base_replace_indexes(container, from, to, 1);
                DerivedPolicies::set_slice(container, from, to, elem());
            }
            else
            {

                extract<Data> elem(v);
                if (elem.check())
                {
                    ProxyHandler::base_replace_indexes(container, from, to, 1);
                    DerivedPolicies::set_slice(container, from, to, elem());
                }
                else
                {

                    handle<> l_(python::borrowed(v));
                    object l(l_);

                    std::vector<Data> temp;
                    for (int i = 0; i < l.attr("__len__")(); i++)
                    {
                        object elem(l[i]);
                        extract<Data const&> x(elem);

                        if (x.check())
                        {
                            temp.push_back(x());
                        }
                        else
                        {

                            extract<Data> x(elem);
                            if (x.check())
                            {
                                temp.push_back(x());
                            }
                            else
                            {
                                PyErr_SetString(PyExc_TypeError,
                                    "Invalid sequence element");
                                throw_error_already_set();
                            }
                        }
                    }

                    ProxyHandler::base_replace_indexes(container, from, to,
                        temp.end()-temp.begin());
                    DerivedPolicies::set_slice(container, from, to,
                        temp.begin(), temp.end());
                }
            }
        }

        static void
        base_delete_slice(Container& container, PySliceObject* slice)
        {
            Index from, to;
            base_get_slice_data(container, slice, from, to);
            ProxyHandler::base_erase_indexes(container, from, to);
            DerivedPolicies::delete_slice(container, from, to);
        }
    };

    template <
          class Container
        , class DerivedPolicies
        , class ProxyHandler
        , class Data
        , class Index
    >
    struct no_slice_helper
    {
        static void
        slicing_not_suported()
        {
            PyErr_SetString(PyExc_RuntimeError, "Slicing not supported");
            throw_error_already_set();
        }

        static object
        base_get_slice(Container& , PySliceObject* )
        {
            slicing_not_suported();
            return object();
        }

        static void
        base_set_slice(Container& , PySliceObject* , PyObject* )
        {
            slicing_not_suported();
        }

        static void
        base_delete_slice(Container& , PySliceObject* )
        {
            slicing_not_suported();
        }
    };





    template <class Container, class Index, class Policies>
    inline typename Policies::data_type*
    get_pointer(
        python::detail::container_element<Container, Index, Policies> const& p)
    {

        return p.get();
    }



    using boost::python::get_pointer;
    using boost::get_pointer;
}}


}
# 13 "/usr/include/boost-1_42/boost/python/suite/indexing/indexing_suite.hpp" 2






namespace boost { namespace python {
# 98 "/usr/include/boost-1_42/boost/python/suite/indexing/indexing_suite.hpp"
    template <
          class Container
        , class DerivedPolicies
        , bool NoProxy = false
        , bool NoSlice = false
        , class Data = typename Container::value_type
        , class Index = typename Container::size_type
        , class Key = typename Container::value_type
    >
    class indexing_suite
        : public def_visitor<
            indexing_suite<
              Container
            , DerivedPolicies
            , NoProxy
            , NoSlice
            , Data
            , Index
            , Key
        > >
    {
    private:

        typedef mpl::or_<
            mpl::bool_<NoProxy>
          , mpl::not_<is_class<Data> >
          , typename mpl::or_<
                is_same<Data, std::string>
              , is_same<Data, std::complex<float> >
              , is_same<Data, std::complex<double> >
              , is_same<Data, std::complex<long double> > >::type>
        no_proxy;

        typedef detail::container_element<Container, Index, DerivedPolicies>
            container_element_t;




        typedef return_internal_reference<> return_policy;


        typedef typename mpl::if_<
            no_proxy
          , iterator<Container>
          , iterator<Container, return_policy> >::type
        def_iterator;

        typedef typename mpl::if_<
            no_proxy
          , detail::no_proxy_helper<
                Container
              , DerivedPolicies
              , container_element_t
              , Index>
          , detail::proxy_helper<
                Container
              , DerivedPolicies
              , container_element_t
              , Index> >::type
        proxy_handler;

        typedef typename mpl::if_<
            mpl::bool_<NoSlice>
          , detail::no_slice_helper<
                Container
              , DerivedPolicies
              , proxy_handler
              , Data
              , Index>
          , detail::slice_helper<
                Container
              , DerivedPolicies
              , proxy_handler
              , Data
              , Index> >::type
        slice_handler;

    public:

        template <class Class>
        void visit(Class& cl) const
        {

            proxy_handler::register_container_element();

            cl
                .def("__len__", base_size)
                .def("__setitem__", &base_set_item)
                .def("__delitem__", &base_delete_item)
                .def("__getitem__", &base_get_item)
                .def("__contains__", &base_contains)
                .def("__iter__", def_iterator())
            ;

            DerivedPolicies::extension_def(cl);
        }

        template <class Class>
        static void
        extension_def(Class& cl)
        {


        }

    private:

        static object
        base_get_item(back_reference<Container&> container, PyObject* i)
        {
            if (((((PyObject*)(i))->ob_type) == &PySlice_Type))
                return slice_handler::base_get_slice(
                    container.get(), static_cast<PySliceObject*>(static_cast<void*>(i)));

            return proxy_handler::base_get_item_(container, i);
        }

        static void
        base_set_item(Container& container, PyObject* i, PyObject* v)
        {
            if (((((PyObject*)(i))->ob_type) == &PySlice_Type))
            {
                 slice_handler::base_set_slice(container,
                     static_cast<PySliceObject*>(static_cast<void*>(i)), v);
            }
            else
            {
                extract<Data&> elem(v);

                if (elem.check())
                {
                    DerivedPolicies::
                        set_item(container,
                            DerivedPolicies::
                                convert_index(container, i), elem());
                }
                else
                {

                    extract<Data> elem(v);
                    if (elem.check())
                    {
                        DerivedPolicies::
                            set_item(container,
                                DerivedPolicies::
                                    convert_index(container, i), elem());
                    }
                    else
                    {
                        PyErr_SetString(PyExc_TypeError, "Invalid assignment");
                        throw_error_already_set();
                    }
                }
            }
        }

        static void
        base_delete_item(Container& container, PyObject* i)
        {
            if (((((PyObject*)(i))->ob_type) == &PySlice_Type))
            {
                slice_handler::base_delete_slice(
                    container, static_cast<PySliceObject*>(static_cast<void*>(i)));
                return;
            }

            Index index = DerivedPolicies::convert_index(container, i);
            proxy_handler::base_erase_index(container, index, mpl::bool_<NoSlice>());
            DerivedPolicies::delete_item(container, index);
        }

        static size_t
        base_size(Container& container)
        {
            return DerivedPolicies::size(container);
        }

        static bool
        base_contains(Container& container, PyObject* key)
        {
            extract<Key const&> x(key);

            if (x.check())
            {
                return DerivedPolicies::contains(container, x());
            }
            else
            {

                extract<Key> x(key);
                if (x.check())
                    return DerivedPolicies::contains(container, x());
                else
                    return false;
            }
        }
    };

}}
# 33 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 2
# 1 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
# 1 "/usr/include/boost-1_42/boost/foreach.hpp" 1
# 26 "/usr/include/boost-1_42/boost/foreach.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 27 "/usr/include/boost-1_42/boost/foreach.hpp" 2
# 68 "/usr/include/boost-1_42/boost/foreach.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/logical.hpp" 1
# 69 "/usr/include/boost-1_42/boost/foreach.hpp" 2


# 1 "/usr/include/boost-1_42/boost/range/end.hpp" 1
# 18 "/usr/include/boost-1_42/boost/range/end.hpp"
# 1 "/usr/include/boost-1_42/boost/range/config.hpp" 1
# 19 "/usr/include/boost-1_42/boost/range/end.hpp" 2





# 1 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp" 1
# 15 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp"
# 1 "/usr/include/boost-1_42/boost/range/detail/common.hpp" 1
# 19 "/usr/include/boost-1_42/boost/range/detail/common.hpp"
# 1 "/usr/include/boost-1_42/boost/range/detail/sfinae.hpp" 1
# 20 "/usr/include/boost-1_42/boost/range/detail/sfinae.hpp"
namespace boost
{
    namespace range_detail
    {
        using type_traits::yes_type;
        using type_traits::no_type;





        yes_type is_string_impl( const char* const );
        yes_type is_string_impl( const wchar_t* const );
        no_type is_string_impl( ... );

        template< std::size_t sz >
        yes_type is_char_array_impl( char (&boost_range_array)[sz] );
        template< std::size_t sz >
        yes_type is_char_array_impl( const char (&boost_range_array)[sz] );
        no_type is_char_array_impl( ... );

        template< std::size_t sz >
        yes_type is_wchar_t_array_impl( wchar_t (&boost_range_array)[sz] );
        template< std::size_t sz >
        yes_type is_wchar_t_array_impl( const wchar_t (&boost_range_array)[sz] );
        no_type is_wchar_t_array_impl( ... );

        yes_type is_char_ptr_impl( char* const );
        no_type is_char_ptr_impl( ... );

        yes_type is_const_char_ptr_impl( const char* const );
        no_type is_const_char_ptr_impl( ... );

        yes_type is_wchar_t_ptr_impl( wchar_t* const );
        no_type is_wchar_t_ptr_impl( ... );

        yes_type is_const_wchar_t_ptr_impl( const wchar_t* const );
        no_type is_const_wchar_t_ptr_impl( ... );





        template< typename Iterator >
        yes_type is_pair_impl( const std::pair<Iterator,Iterator>* );
        no_type is_pair_impl( ... );





        struct char_or_wchar_t_array_tag {};

    }

}
# 20 "/usr/include/boost-1_42/boost/range/detail/common.hpp" 2




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 25 "/usr/include/boost-1_42/boost/range/detail/common.hpp" 2





namespace boost
{
    namespace range_detail
    {
# 47 "/usr/include/boost-1_42/boost/range/detail/common.hpp"
        typedef mpl::int_<1>::type std_container_;
        typedef mpl::int_<2>::type std_pair_;
        typedef mpl::int_<3>::type const_std_pair_;
        typedef mpl::int_<4>::type array_;
        typedef mpl::int_<5>::type const_array_;
        typedef mpl::int_<6>::type char_array_;
        typedef mpl::int_<7>::type wchar_t_array_;
        typedef mpl::int_<8>::type char_ptr_;
        typedef mpl::int_<9>::type const_char_ptr_;
        typedef mpl::int_<10>::type wchar_t_ptr_;
        typedef mpl::int_<11>::type const_wchar_t_ptr_;
        typedef mpl::int_<12>::type string_;

        template< typename C >
        struct range_helper
        {
            static C* c;
            static C ptr;

            static const bool is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type );
            static const bool is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_string_ = (boost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value );
            static const bool is_array_ = boost::is_array<C>::value;

        };

        template< typename C >
        class range
        {
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_,
                                                                  boost::range_detail::std_pair_,
                                                                  void >::type pair_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_,
                                                                    boost::range_detail::array_,
                                                                    pair_t >::type array_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_,
                                                                    boost::range_detail::string_,
                                                                    array_t >::type string_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_,
                                                                    boost::range_detail::const_char_ptr_,
                                                                    string_t >::type const_char_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_,
                                                                    boost::range_detail::char_ptr_,
                                                                    const_char_ptr_t >::type char_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
                                                                    boost::range_detail::const_wchar_t_ptr_,
                                                                    char_ptr_t >::type const_wchar_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
                                                                    boost::range_detail::wchar_t_ptr_,
                                                                    const_wchar_ptr_t >::type wchar_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_,
                                                                    boost::range_detail::wchar_t_array_,
                                                                    wchar_ptr_t >::type wchar_array_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_,
                                                                    boost::range_detail::char_array_,
                                                                    wchar_array_t >::type char_array_t;
        public:
            typedef typename boost::mpl::if_c< ::boost::is_void<char_array_t>::value,
                                                                    boost::range_detail::std_container_,
                                                                    char_array_t >::type type;
        };
    }
}
# 16 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 18 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp" 2



# 1 "/usr/include/wchar.h" 1 3 4
# 22 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp" 2


namespace boost
{
    namespace range_detail
    {
        template <typename T>
        inline void boost_range_silence_warning( const T& ) { }





        inline const char* str_end( const char* s, const char* )
        {
            return s + strlen( s );
        }


        inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
        {
            return s + wcslen( s );
        }
# 56 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp"
        template< class Char >
        inline Char* str_end( Char* s )
        {
            return const_cast<Char*>( str_end( s, s ) );
        }

        template< class T, std::size_t sz >
        inline T* array_end( T (&boost_range_array)[sz] )
        {
            return boost_range_array + sz;
        }

        template< class T, std::size_t sz >
        inline const T* array_end( const T (&boost_range_array)[sz] )
        {
            return boost_range_array + sz;
        }





        template< class Char >
        inline std::size_t str_size( const Char* const& s )
        {
            return str_end( s ) - s;
        }

        template< class T, std::size_t sz >
        inline std::size_t array_size( T (&boost_range_array)[sz] )
        {
            boost_range_silence_warning( boost_range_array );
            return sz;
        }

        template< class T, std::size_t sz >
        inline std::size_t array_size( const T (&boost_range_array)[sz] )
        {
            boost_range_silence_warning( boost_range_array );
            return sz;
        }

    }

}
# 25 "/usr/include/boost-1_42/boost/range/end.hpp" 2
# 1 "/usr/include/boost-1_42/boost/range/iterator.hpp" 1
# 19 "/usr/include/boost-1_42/boost/range/iterator.hpp"
# 1 "/usr/include/boost-1_42/boost/range/mutable_iterator.hpp" 1
# 25 "/usr/include/boost-1_42/boost/range/mutable_iterator.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 26 "/usr/include/boost-1_42/boost/range/mutable_iterator.hpp" 2


namespace boost
{




    template< typename C >
    struct range_mutable_iterator
    {
        typedef typename C::iterator type;
    };





    template< typename Iterator >
    struct range_mutable_iterator< std::pair<Iterator,Iterator> >
    {
        typedef Iterator type;
    };





    template< typename T, std::size_t sz >
    struct range_mutable_iterator< T[sz] >
    {
        typedef T* type;
    };

}
# 20 "/usr/include/boost-1_42/boost/range/iterator.hpp" 2
# 1 "/usr/include/boost-1_42/boost/range/const_iterator.hpp" 1
# 25 "/usr/include/boost-1_42/boost/range/const_iterator.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 26 "/usr/include/boost-1_42/boost/range/const_iterator.hpp" 2


namespace boost
{




    template< typename C >
    struct range_const_iterator
    {
        typedef typename C::const_iterator type;
    };





    template< typename Iterator >
    struct range_const_iterator< std::pair<Iterator,Iterator> >
    {
        typedef Iterator type;
    };





    template< typename T, std::size_t sz >
    struct range_const_iterator< T[sz] >
    {
        typedef const T* type;
    };

}
# 21 "/usr/include/boost-1_42/boost/range/iterator.hpp" 2




namespace boost
{
# 50 "/usr/include/boost-1_42/boost/range/iterator.hpp"
    template< typename C >
    struct range_iterator
    {







        typedef typename
            mpl::eval_if_c< is_const<C>::value,
                            range_const_iterator< typename remove_const<C>::type >,
                            range_mutable_iterator<C> >::type type;


    };

}
# 26 "/usr/include/boost-1_42/boost/range/end.hpp" 2


namespace boost
{




namespace range_detail
{





        template< typename C >
        inline typename range_iterator<C>::type
        range_end( C& c )
        {





            return c.end();
        }





        template< typename Iterator >
        inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }

        template< typename Iterator >
        inline Iterator range_end( std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }





        template< typename T, std::size_t sz >
        inline const T* range_end( const T (&a)[sz] )
        {
            return range_detail::array_end<T,sz>( a );
        }

        template< typename T, std::size_t sz >
        inline T* range_end( T (&a)[sz] )
        {
            return range_detail::array_end<T,sz>( a );
        }




}


template< class T >
inline typename range_iterator<T>::type end( T& r )
{



    using namespace range_detail;

    return range_end( r );
}

template< class T >
inline typename range_iterator<const T>::type end( const T& r )
{



    using namespace range_detail;

    return range_end( r );
}

}






namespace boost
{
    template< class T >
    inline typename range_iterator<const T>::type
    const_end( const T& r )
    {
        return boost::end( r );
    }
}
# 72 "/usr/include/boost-1_42/boost/foreach.hpp" 2
# 1 "/usr/include/boost-1_42/boost/range/begin.hpp" 1
# 26 "/usr/include/boost-1_42/boost/range/begin.hpp"
namespace boost
{




namespace range_detail
{






    template< typename C >
    inline typename range_iterator<C>::type
    range_begin( C& c )
    {





        return c.begin();
    }





    template< typename Iterator >
    inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }

    template< typename Iterator >
    inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }
# 75 "/usr/include/boost-1_42/boost/range/begin.hpp"
    template< typename T, std::size_t sz >
    inline const T* range_begin( const T (&a)[sz] )
    {
        return a;
    }

    template< typename T, std::size_t sz >
    inline T* range_begin( T (&a)[sz] )
    {
        return a;
    }





}



template< class T >
inline typename range_iterator<T>::type begin( T& r )
{



    using namespace range_detail;

    return range_begin( r );
}

template< class T >
inline typename range_iterator<const T>::type begin( const T& r )
{



    using namespace range_detail;

    return range_begin( r );
}

}



namespace boost
{
    template< class T >
    inline typename range_iterator<const T>::type
    const_begin( const T& r )
    {
        return boost::begin( r );
    }
}
# 73 "/usr/include/boost-1_42/boost/foreach.hpp" 2
# 1 "/usr/include/boost-1_42/boost/range/rend.hpp" 1
# 19 "/usr/include/boost-1_42/boost/range/rend.hpp"
# 1 "/usr/include/boost-1_42/boost/range/reverse_iterator.hpp" 1
# 20 "/usr/include/boost-1_42/boost/range/reverse_iterator.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator/reverse_iterator.hpp" 1
# 12 "/usr/include/boost-1_42/boost/iterator/reverse_iterator.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp" 1
# 14 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp" 1
# 11 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
# 12 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp" 2





# 1 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 1
# 18 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp" 2






namespace boost {





struct no_traversal_tag {};

struct incrementable_traversal_tag
  : no_traversal_tag
{


};

struct single_pass_traversal_tag
  : incrementable_traversal_tag
{


};

struct forward_traversal_tag
  : single_pass_traversal_tag
{


};

struct bidirectional_traversal_tag
  : forward_traversal_tag
{


};

struct random_access_traversal_tag
  : bidirectional_traversal_tag
{


};

namespace detail
{






  template <class Cat>
  struct old_category_to_traversal
    : mpl::eval_if<
          is_convertible<Cat,std::random_access_iterator_tag>
        , mpl::identity<random_access_traversal_tag>
        , mpl::eval_if<
              is_convertible<Cat,std::bidirectional_iterator_tag>
            , mpl::identity<bidirectional_traversal_tag>
            , mpl::eval_if<
                  is_convertible<Cat,std::forward_iterator_tag>
                , mpl::identity<forward_traversal_tag>
                , mpl::eval_if<
                      is_convertible<Cat,std::input_iterator_tag>
                    , mpl::identity<single_pass_traversal_tag>
                    , mpl::eval_if<
                          is_convertible<Cat,std::output_iterator_tag>
                        , mpl::identity<incrementable_traversal_tag>
                        , void
                      >
                  >
              >
          >
      >
  {};
# 108 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp"
  template <class Traversal>
  struct pure_traversal_tag
    : mpl::eval_if<
          is_convertible<Traversal,random_access_traversal_tag>
        , mpl::identity<random_access_traversal_tag>
        , mpl::eval_if<
              is_convertible<Traversal,bidirectional_traversal_tag>
            , mpl::identity<bidirectional_traversal_tag>
            , mpl::eval_if<
                  is_convertible<Traversal,forward_traversal_tag>
                , mpl::identity<forward_traversal_tag>
                , mpl::eval_if<
                      is_convertible<Traversal,single_pass_traversal_tag>
                    , mpl::identity<single_pass_traversal_tag>
                    , mpl::eval_if<
                          is_convertible<Traversal,incrementable_traversal_tag>
                        , mpl::identity<incrementable_traversal_tag>
                        , void
                      >
                  >
              >
          >
      >
  {
  };
# 142 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp"
}





template <class Cat>
struct iterator_category_to_traversal
  : mpl::eval_if<
        is_convertible<Cat,incrementable_traversal_tag>
      , mpl::identity<Cat>
      , boost::detail::old_category_to_traversal<Cat>
    >
{};


template <class Iterator = mpl::_1>
struct iterator_traversal
  : iterator_category_to_traversal<
        typename boost::detail::iterator_traits<Iterator>::iterator_category
    >
{};
# 184 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp"
}

# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
# 187 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp" 2
# 15 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp" 2
# 1 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 1
# 11 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator/interoperable.hpp" 1
# 15 "/usr/include/boost-1_42/boost/iterator/interoperable.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
# 16 "/usr/include/boost-1_42/boost/iterator/interoperable.hpp" 2

namespace boost
{
# 34 "/usr/include/boost-1_42/boost/iterator/interoperable.hpp"
  template <typename A, typename B>
  struct is_interoperable



    : mpl::or_<
          is_convertible< A, B >
        , is_convertible< B, A > >

  {
  };

}

# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
# 49 "/usr/include/boost-1_42/boost/iterator/interoperable.hpp" 2
# 12 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2


# 1 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp" 1
# 23 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
# 24 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp" 2
# 34 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp"
namespace boost { struct use_default; }

namespace boost { namespace detail {

struct input_output_iterator_tag
  : std::input_iterator_tag
{






    operator std::output_iterator_tag() const
    {
        return std::output_iterator_tag();
    }
};






template <class ValueParam, class Reference>
struct iterator_writability_disabled

  : mpl::or_<
        is_const<Reference>
      , boost::detail::indirect_traits::is_reference_to_const<Reference>
      , is_const<ValueParam>
    >



{};
# 86 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp"
template <class Traversal, class ValueParam, class Reference>
struct iterator_facade_default_category
  : mpl::eval_if<
        mpl::and_<
            is_reference<Reference>
          , is_convertible<Traversal,forward_traversal_tag>
        >
      , mpl::eval_if<
            is_convertible<Traversal,random_access_traversal_tag>
          , mpl::identity<std::random_access_iterator_tag>
          , mpl::if_<
                is_convertible<Traversal,bidirectional_traversal_tag>
              , std::bidirectional_iterator_tag
              , std::forward_iterator_tag
            >
        >
      , typename mpl::eval_if<
            mpl::and_<
                is_convertible<Traversal, single_pass_traversal_tag>


              , is_convertible<Reference, ValueParam>
            >
          , mpl::identity<std::input_iterator_tag>
          , mpl::identity<Traversal>
        >
    >
{
};


template <class T>
struct is_iterator_category
  : mpl::or_<
        is_convertible<T,std::input_iterator_tag>
      , is_convertible<T,std::output_iterator_tag>
    >
{
};

template <class T>
struct is_iterator_traversal
  : is_convertible<T,incrementable_traversal_tag>
{};







template <class Category, class Traversal>
struct iterator_category_with_traversal
  : Category, Traversal
{




    enum { mpl_assertion_in_line_149 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) ( is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >))0, 1 ) ) ) }



             ;

    enum { mpl_assertion_in_line_151 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_category<Category>))0, 1 ) ) ) };
    enum { mpl_assertion_in_line_152 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
    enum { mpl_assertion_in_line_153 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_traversal<Category>))0, 1 ) ) ) };

    enum { mpl_assertion_in_line_155 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_traversal<Traversal>))0, 1 ) ) ) };


};



template <class Traversal, class ValueParam, class Reference>
struct facade_iterator_category_impl
{

    enum { mpl_assertion_in_line_166 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };


    typedef typename iterator_facade_default_category<
        Traversal,ValueParam,Reference
    >::type category;

    typedef typename mpl::if_<
        is_same<
            Traversal
          , typename iterator_category_to_traversal<category>::type
        >
      , category
      , iterator_category_with_traversal<category,Traversal>
    >::type type;
};




template <class CategoryOrTraversal, class ValueParam, class Reference>
struct facade_iterator_category
  : mpl::eval_if<
        is_iterator_category<CategoryOrTraversal>
      , mpl::identity<CategoryOrTraversal>
      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
    >
{
};

}}

# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
# 199 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp" 2
# 15 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2
# 33 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
# 1 "/usr/include/boost-1_42/boost/mpl/always.hpp" 1
# 21 "/usr/include/boost-1_42/boost/mpl/always.hpp"
namespace boost { namespace mpl {

template< typename Value > struct always
{
    template<
          typename T
        , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na
        >
    struct apply
    {
        typedef Value type;
    };
};



}}
# 34 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2
# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
# 35 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2


# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
# 38 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2

namespace boost
{


  template <class I, class V, class TC, class R, class D> class iterator_facade;

  namespace detail
  {



    struct always_bool2
    {
        template <class T, class U>
        struct apply
        {
            typedef bool type;
        };
    };




    template <
        class Facade1
      , class Facade2
      , class Return
    >
    struct enable_if_interoperable
# 80 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
      : ::boost::iterators::enable_if<
           mpl::or_<
               is_convertible<Facade1, Facade2>
             , is_convertible<Facade2, Facade1>
           >
         , Return
        >
    {};






    template <
        class ValueParam
      , class CategoryOrTraversal
      , class Reference
      , class Difference
    >
    struct iterator_facade_types
    {
        typedef typename facade_iterator_category<
            CategoryOrTraversal, ValueParam, Reference
        >::type iterator_category;

        typedef typename remove_const<ValueParam>::type value_type;

        typedef typename mpl::eval_if<
            boost::detail::iterator_writability_disabled<ValueParam,Reference>
          , add_pointer<const value_type>
          , add_pointer<value_type>
        >::type pointer;
# 130 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
    };







    template <class Iterator>
    class postfix_increment_proxy
    {
        typedef typename iterator_value<Iterator>::type value_type;
     public:
        explicit postfix_increment_proxy(Iterator const& x)
          : stored_value(*x)
        {}





        value_type&
        operator*() const
        {
            return this->stored_value;
        }
     private:
        mutable value_type stored_value;
    };





    template <class Iterator>
    class writable_postfix_increment_proxy
    {
        typedef typename iterator_value<Iterator>::type value_type;
     public:
        explicit writable_postfix_increment_proxy(Iterator const& x)
          : stored_value(*x)
          , stored_iterator(x)
        {}





        writable_postfix_increment_proxy const&
        operator*() const
        {
            return *this;
        }


        operator value_type&() const
        {
            return stored_value;
        }


        template <class T>
        T const& operator=(T const& x) const
        {
            *this->stored_iterator = x;
            return x;
        }


        template <class T>
        T& operator=(T& x) const
        {
            *this->stored_iterator = x;
            return x;
        }


        operator Iterator const&() const
        {
            return stored_iterator;
        }

     private:
        mutable value_type stored_value;
        Iterator stored_iterator;
    };
# 244 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
    template <class Reference, class Value>
    struct is_non_proxy_reference
      : is_convertible<
            typename remove_reference<Reference>::type
            const volatile*
          , Value const volatile*
        >
    {};
# 269 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
    struct postfix_increment_result
      : mpl::eval_if<
            mpl::and_<

                is_convertible<Reference,Value const&>



              , mpl::not_<
                    is_convertible<
                        typename iterator_category_to_traversal<CategoryOrTraversal>::type
                      , forward_traversal_tag
                    >
                >
            >
          , mpl::if_<
                is_non_proxy_reference<Reference,Value>
              , postfix_increment_proxy<Iterator>
              , writable_postfix_increment_proxy<Iterator>
            >
          , mpl::identity<Iterator>
        >
    {};





    template <class T>
    struct operator_arrow_proxy
    {
        operator_arrow_proxy(T const* px) : m_value(*px) {}
        T* operator->() const { return &m_value; }


        operator T*() const { return &m_value; }
        mutable T m_value;
    };




    template <class ValueType, class Reference, class Pointer>
    struct operator_arrow_result
    {



        typedef typename mpl::if_<
            is_reference<Reference>
          , Pointer
          , operator_arrow_proxy<ValueType>
        >::type type;

        static type make(Reference x)
        {
            return implicit_cast<type>(&x);
        }
    };
# 342 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
    template <class Iterator>
    class operator_brackets_proxy
    {


        typedef typename Iterator::reference reference;
        typedef typename Iterator::value_type value_type;

     public:
        operator_brackets_proxy(Iterator const& iter)
          : m_iter(iter)
        {}

        operator reference() const
        {
            return *m_iter;
        }

        operator_brackets_proxy& operator=(value_type const& val)
        {
            *m_iter = val;
            return *this;
        }

     private:
        Iterator m_iter;
    };



    template <class ValueType, class Reference>
    struct use_operator_brackets_proxy
      : mpl::not_<
            mpl::and_<


                boost::is_POD<ValueType>
              , iterator_writability_disabled<ValueType,Reference>
            >
        >
    {};

    template <class Iterator, class Value, class Reference>
    struct operator_brackets_result
    {
        typedef typename mpl::if_<
            use_operator_brackets_proxy<Value,Reference>
          , operator_brackets_proxy<Iterator>
          , Value
        >::type type;
    };

    template <class Iterator>
    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)
    {
        return operator_brackets_proxy<Iterator>(iter);
    }

    template <class Iterator>
    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)
    {
      return *iter;
    }

    struct choose_difference_type
    {
        template <class I1, class I2>
        struct apply
          :
# 420 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
          mpl::eval_if<
              is_convertible<I2,I1>
            , iterator_difference<I1>
            , iterator_difference<I2>
          >

        {};

    };
  }
# 471 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
  class iterator_core_access
  {






      template <class I, class V, class TC, class R, class D> friend class iterator_facade;




      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);

      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);


      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)

      ;

      template <class Derived, class V, class TC, class R, class D> friend inline Derived operator+ (iterator_facade<Derived, V, TC, R, D> const& , typename Derived::difference_type)




      ;

      template <class Derived, class V, class TC, class R, class D> friend inline Derived operator+ (typename Derived::difference_type , iterator_facade<Derived, V, TC, R, D> const&)




      ;



      template <class Facade>
      static typename Facade::reference dereference(Facade const& f)
      {
          return f.dereference();
      }

      template <class Facade>
      static void increment(Facade& f)
      {
          f.increment();
      }

      template <class Facade>
      static void decrement(Facade& f)
      {
          f.decrement();
      }

      template <class Facade1, class Facade2>
      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
      {
          return f1.equal(f2);
      }

      template <class Facade1, class Facade2>
      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
      {
          return f2.equal(f1);
      }

      template <class Facade>
      static void advance(Facade& f, typename Facade::difference_type n)
      {
          f.advance(n);
      }

      template <class Facade1, class Facade2>
      static typename Facade1::difference_type distance_from(
          Facade1 const& f1, Facade2 const& f2, mpl::true_)
      {
          return -f1.distance_to(f2);
      }

      template <class Facade1, class Facade2>
      static typename Facade2::difference_type distance_from(
          Facade1 const& f1, Facade2 const& f2, mpl::false_)
      {
          return f2.distance_to(f1);
      }




      template <class I, class V, class TC, class R, class D>
      static I& derived(iterator_facade<I,V,TC,R,D>& facade)
      {
          return *static_cast<I*>(&facade);
      }

      template <class I, class V, class TC, class R, class D>
      static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
      {
          return *static_cast<I const*>(&facade);
      }

   private:

      iterator_core_access();
  };





  template <
      class Derived
    , class Value
    , class CategoryOrTraversal
    , class Reference = Value&
    , class Difference = std::ptrdiff_t
  >
  class iterator_facade






  {
   private:



      Derived& derived()
      {
          return *static_cast<Derived*>(this);
      }

      Derived const& derived() const
      {
          return *static_cast<Derived const*>(this);
      }

      typedef boost::detail::iterator_facade_types<
         Value, CategoryOrTraversal, Reference, Difference
      > associated_types;

   protected:

      typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;

   public:

      typedef typename associated_types::value_type value_type;
      typedef Reference reference;
      typedef Difference difference_type;
      typedef typename associated_types::pointer pointer;
      typedef typename associated_types::iterator_category iterator_category;

      reference operator*() const
      {
          return iterator_core_access::dereference(this->derived());
      }

      typename boost::detail::operator_arrow_result<
          value_type
        , reference
        , pointer
      >::type
      operator->() const
      {
          return boost::detail::operator_arrow_result<
              value_type
            , reference
            , pointer
          >::make(*this->derived());
      }

      typename boost::detail::operator_brackets_result<Derived,Value,reference>::type
      operator[](difference_type n) const
      {
          typedef boost::detail::use_operator_brackets_proxy<Value,Reference> use_proxy;

          return boost::detail::make_operator_brackets_result<Derived>(
              this->derived() + n
            , use_proxy()
          );
      }

      Derived& operator++()
      {
          iterator_core_access::increment(this->derived());
          return this->derived();
      }
# 679 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
      Derived& operator--()
      {
          iterator_core_access::decrement(this->derived());
          return this->derived();
      }

      Derived operator--(int)
      {
          Derived tmp(this->derived());
          --*this;
          return tmp;
      }

      Derived& operator+=(difference_type n)
      {
          iterator_core_access::advance(this->derived(), n);
          return this->derived();
      }

      Derived& operator-=(difference_type n)
      {
          iterator_core_access::advance(this->derived(), -n);
          return this->derived();
      }

      Derived operator-(difference_type x) const
      {
          Derived result(this->derived());
          return result -= x;
      }
# 721 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
  };


  template <class I, class V, class TC, class R, class D>
  inline typename boost::detail::postfix_increment_result<I,V,R,TC>::type
  operator++(
      iterator_facade<I,V,TC,R,D>& i
    , int
  )
  {
      typename boost::detail::postfix_increment_result<I,V,R,TC>::type
          tmp(*static_cast<I*>(&i));

      ++i;

      return tmp;
  }
# 836 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_836; return iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_837; return ! iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }

  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_839; return 0 > iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_840; return 0 < iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_841; return 0 >= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_842; return 0 <= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }



  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)>




 boost_static_assert_typedef_851
# 846 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
  ; return iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
# 862 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( iterator_facade<Derived, V, TC, R, D> const& i , typename Derived::difference_type n ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }




template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( typename Derived::difference_type n , iterator_facade<Derived, V, TC, R, D> const& i ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }






}

# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
# 877 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2
# 16 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp" 2
# 36 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp"
# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
# 37 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp" 2



namespace boost
{



  struct use_default;





  template<class To>
  struct is_convertible<use_default,To>
    : mpl::false_ {};


  namespace detail
  {
# 66 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp"
    struct enable_type;
  }
# 148 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp"
  template<typename From, typename To>
  struct enable_if_convertible
    : iterators::enable_if<
          is_convertible<From, To>
        , boost::detail::enable_type
      >
  {};






  namespace detail
  {


    template <class T, class DefaultNullaryFn>
    struct ia_dflt_help
      : mpl::eval_if<
            is_same<T, use_default>
          , DefaultNullaryFn
          , mpl::identity<T>
        >
    {
    };



    template <
        class Derived
      , class Base
      , class Value
      , class Traversal
      , class Reference
      , class Difference
    >
    struct iterator_adaptor_base
    {
        typedef iterator_facade<
            Derived


          , typename boost::detail::ia_dflt_help<
                Value
              , mpl::eval_if<
                    is_same<Reference,use_default>
                  , iterator_value<Base>
                  , remove_reference<Reference>
                >
            >::type






          , typename boost::detail::ia_dflt_help<
                Traversal
              , iterator_traversal<Base>
            >::type

          , typename boost::detail::ia_dflt_help<
                Reference
              , mpl::eval_if<
                    is_same<Value,use_default>
                  , iterator_reference<Base>
                  , add_reference<Value>
                >
            >::type

          , typename boost::detail::ia_dflt_help<
                Difference, iterator_difference<Base>
            >::type
        >
        type;
    };


    template <class Tr1, class Tr2>
    inline void iterator_adaptor_assert_traversal ()
    {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_convertible<Tr1, Tr2>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_230;
    }
  }
# 259 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp"
  template <
      class Derived
    , class Base
    , class Value = use_default
    , class Traversal = use_default
    , class Reference = use_default
    , class Difference = use_default
  >
  class iterator_adaptor
    : public boost::detail::iterator_adaptor_base<
        Derived, Base, Value, Traversal, Reference, Difference
      >::type
  {
      friend class iterator_core_access;

   protected:
      typedef typename boost::detail::iterator_adaptor_base<
          Derived, Base, Value, Traversal, Reference, Difference
      >::type super_t;
   public:
      iterator_adaptor() {}

      explicit iterator_adaptor(Base const &iter)
          : m_iterator(iter)
      {
      }

      typedef Base base_type;

      Base const& base() const
        { return m_iterator; }

   protected:

      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;




      Base const& base_reference() const
        { return m_iterator; }

      Base& base_reference()
        { return m_iterator; }

   private:






      typename super_t::reference dereference() const
        { return *m_iterator; }

      template <
      class OtherDerived, class OtherIterator, class V, class C, class R, class D
      >
      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
      {




          return m_iterator == x.base();
      }

      typedef typename iterator_category_to_traversal<
          typename super_t::iterator_category
      >::type my_traversal;




      void advance(typename super_t::difference_type n)
      {
          boost::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
          m_iterator += n;
      }

      void increment() { ++m_iterator; }

      void decrement()
      {
          boost::detail::iterator_adaptor_assert_traversal<my_traversal, bidirectional_traversal_tag>();
           --m_iterator;
      }

      template <
          class OtherDerived, class OtherIterator, class V, class C, class R, class D
      >
      typename super_t::difference_type distance_to(
          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
      {
          boost::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();




          return y.base() - m_iterator;
      }



   private:
      Base m_iterator;
  };

}

# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
# 370 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp" 2
# 13 "/usr/include/boost-1_42/boost/iterator/reverse_iterator.hpp" 2

namespace boost
{




  template <class Iterator>
  class reverse_iterator
      : public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
  {
      typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;

      friend class iterator_core_access;

   public:
      reverse_iterator() {}

      explicit reverse_iterator(Iterator x)
          : super_t(x) {}

      template<class OtherIterator>
      reverse_iterator(
          reverse_iterator<OtherIterator> const& r
          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
          )
          : super_t(r.base())
      {}

   private:
      typename super_t::reference dereference() const { return *boost::prior(this->base()); }

      void increment() { --this->base_reference(); }
      void decrement() { ++this->base_reference(); }

      void advance(typename super_t::difference_type n)
      {
          this->base_reference() += -n;
      }

      template <class OtherIterator>
      typename super_t::difference_type
      distance_to(reverse_iterator<OtherIterator> const& y) const
      {
          return this->base_reference() - y.base();
      }
  };

  template <class BidirectionalIterator>
  reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
  {
      return reverse_iterator<BidirectionalIterator>(x);
  }

}
# 21 "/usr/include/boost-1_42/boost/range/reverse_iterator.hpp" 2


namespace boost
{




    template< typename C >
    struct range_reverse_iterator
    {
        typedef reverse_iterator<
            typename range_iterator<C>::type > type;
    };


}
# 20 "/usr/include/boost-1_42/boost/range/rend.hpp" 2

namespace boost
{
# 35 "/usr/include/boost-1_42/boost/range/rend.hpp"
template< class C >
inline typename range_reverse_iterator<C>::type
rend( C& c )
{
    typedef typename range_reverse_iterator<C>::type
               iter_type;
    return iter_type( boost::begin( c ) );
}

template< class C >
inline typename range_reverse_iterator<const C>::type
rend( const C& c )
{
    typedef typename range_reverse_iterator<const C>::type
        iter_type;
    return iter_type( boost::begin( c ) );
}



template< class T >
inline typename range_reverse_iterator<const T>::type
const_rend( const T& r )
{
    return boost::rend( r );
}

}
# 74 "/usr/include/boost-1_42/boost/foreach.hpp" 2
# 1 "/usr/include/boost-1_42/boost/range/rbegin.hpp" 1
# 21 "/usr/include/boost-1_42/boost/range/rbegin.hpp"
namespace boost
{
# 35 "/usr/include/boost-1_42/boost/range/rbegin.hpp"
template< class C >
inline typename range_reverse_iterator<C>::type
rbegin( C& c )
{
    typedef typename range_reverse_iterator<C>::type
        iter_type;
    return iter_type( boost::end( c ) );
}

template< class C >
inline typename range_reverse_iterator<const C>::type
rbegin( const C& c )
{
    typedef typename range_reverse_iterator<const C>::type
        iter_type;
    return iter_type( boost::end( c ) );
}



template< class T >
inline typename range_reverse_iterator<const T>::type
const_rbegin( const T& r )
{
    return boost::rbegin( r );
}

}
# 75 "/usr/include/boost-1_42/boost/foreach.hpp" 2
# 92 "/usr/include/boost-1_42/boost/foreach.hpp"
enum boost_foreach_argument_dependent_lookup_hack
{
    boost_foreach_argument_dependent_lookup_hack_value
};

namespace boost
{


template<typename T>
class iterator_range;


template<typename T>
class sub_range;

namespace
# 2301 "/usr/include/qt4/QtCore/qglobal.h"
                    Q_FOREACH
# 109 "/usr/include/boost-1_42/boost/foreach.hpp"
{



    template<typename T>
    inline std::pair<T, T> in_range(T begin, T end)
    {
        return std::make_pair(begin, end);
    }




    typedef boost_foreach_argument_dependent_lookup_hack tag;





    template<typename T>
    struct is_lightweight_proxy
      : boost::mpl::false_
    {
    };





    template<typename T>
    struct is_noncopyable

      : boost::mpl::or_<
            boost::is_abstract<T>
          , boost::is_base_and_derived<boost::noncopyable, T>
        >







    {
    };

}

}
# 171 "/usr/include/boost-1_42/boost/foreach.hpp"
template<typename T>
inline boost::
# 2301 "/usr/include/qt4/QtCore/qglobal.h"
                    Q_FOREACH
# 172 "/usr/include/boost-1_42/boost/foreach.hpp"
                     ::is_lightweight_proxy<T> *
boost_foreach_is_lightweight_proxy(T *&, boost::
# 2301 "/usr/include/qt4/QtCore/qglobal.h"
                    Q_FOREACH
# 173 "/usr/include/boost-1_42/boost/foreach.hpp"
                                         ::tag) { return 0; }

template<typename T>
inline boost::mpl::true_ *
boost_foreach_is_lightweight_proxy(std::pair<T, T> *&, boost::
# 2301 "/usr/include/qt4/QtCore/qglobal.h"
                    Q_FOREACH
# 177 "/usr/include/boost-1_42/boost/foreach.hpp"
                                                                     ::tag) { return 0; }

template<typename T>
inline boost::mpl::true_ *
boost_foreach_is_lightweight_proxy(boost::iterator_range<T> *&, boost::
# 2301 "/usr/include/qt4/QtCore/qglobal.h"
                    Q_FOREACH
# 181 "/usr/include/boost-1_42/boost/foreach.hpp"
                                                                              ::tag) { return 0; }

template<typename T>
inline boost::mpl::true_ *
boost_foreach_is_lightweight_proxy(boost::sub_range<T> *&, boost::
# 2301 "/usr/include/qt4/QtCore/qglobal.h"
                    Q_FOREACH
# 185 "/usr/include/boost-1_42/boost/foreach.hpp"
                                                                         ::tag) { return 0; }

template<typename T>
inline boost::mpl::true_ *
boost_foreach_is_lightweight_proxy(T **&, boost::
# 2301 "/usr/include/qt4/QtCore/qglobal.h"
                    Q_FOREACH
# 189 "/usr/include/boost-1_42/boost/foreach.hpp"
                                                        ::tag) { return 0; }






template<typename T>
inline boost::
# 2301 "/usr/include/qt4/QtCore/qglobal.h"
                    Q_FOREACH
# 197 "/usr/include/boost-1_42/boost/foreach.hpp"
                     ::is_noncopyable<T> *
boost_foreach_is_noncopyable(T *&, boost::
# 2301 "/usr/include/qt4/QtCore/qglobal.h"
                    Q_FOREACH
# 198 "/usr/include/boost-1_42/boost/foreach.hpp"
                                   ::tag) { return 0; }

namespace boost
{

namespace foreach_detail_
{




template<typename Bool1, typename Bool2>
inline boost::mpl::and_<Bool1, Bool2> *and_(Bool1 *, Bool2 *) { return 0; }

template<typename Bool1, typename Bool2, typename Bool3>
inline boost::mpl::and_<Bool1, Bool2, Bool3> *and_(Bool1 *, Bool2 *, Bool3 *) { return 0; }

template<typename Bool1, typename Bool2>
inline boost::mpl::or_<Bool1, Bool2> *or_(Bool1 *, Bool2 *) { return 0; }

template<typename Bool1, typename Bool2, typename Bool3>
inline boost::mpl::or_<Bool1, Bool2, Bool3> *or_(Bool1 *, Bool2 *, Bool3 *) { return 0; }

template<typename Bool1>
inline boost::mpl::not_<Bool1> *not_(Bool1 *) { return 0; }

template<typename T>
inline boost::mpl::false_ *is_rvalue_(T &, int) { return 0; }

template<typename T>
inline boost::mpl::true_ *is_rvalue_(T const &, ...) { return 0; }

template<typename T>
inline boost::is_array<T> *is_array_(T const &) { return 0; }

template<typename T>
inline boost::is_const<T> *is_const_(T &) { return 0; }


template<typename T>
inline boost::mpl::true_ *is_const_(T const &) { return 0; }





struct auto_any_base
{


    operator bool() const
    {
        return false;
    }
};

template<typename T>
struct auto_any : auto_any_base
{
    auto_any(T const &t)
      : item(t)
    {
    }




    mutable T item;
};

typedef auto_any_base const &auto_any_t;

template<typename T, typename C>
inline typename boost::mpl::if_<C, T const, T>::type &auto_any_cast(auto_any_t a)
{
    return static_cast<auto_any<T> const &>(a).item;
}

typedef boost::mpl::true_ const_;




template<typename T, typename C = boost::mpl::false_>
struct type2type
  : boost::mpl::if_<C, T const, T>
{
};

template<typename T>
struct wrap_cstr
{
    typedef T type;
};

template<>
struct wrap_cstr<char *>
{
    typedef wrap_cstr<char *> type;
    typedef char *iterator;
    typedef char *const_iterator;
};

template<>
struct wrap_cstr<char const *>
{
    typedef wrap_cstr<char const *> type;
    typedef char const *iterator;
    typedef char const *const_iterator;
};

template<>
struct wrap_cstr<wchar_t *>
{
    typedef wrap_cstr<wchar_t *> type;
    typedef wchar_t *iterator;
    typedef wchar_t *const_iterator;
};

template<>
struct wrap_cstr<wchar_t const *>
{
    typedef wrap_cstr<wchar_t const *> type;
    typedef wchar_t const *iterator;
    typedef wchar_t const *const_iterator;
};

template<typename T>
struct is_char_array
  : mpl::and_<
        is_array<T>
      , mpl::or_<
            is_convertible<T, char const *>
          , is_convertible<T, wchar_t const *>
        >
    >
{};

template<typename T, typename C = boost::mpl::false_>
struct foreach_iterator
{
# 352 "/usr/include/boost-1_42/boost/foreach.hpp"
    struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING; typedef struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING352 : boost::mpl::assert_ { static boost::mpl::failed ************ (IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING::************ assert_arg()) (T&) { return 0; } } mpl_assert_arg352; enum { mpl_assertion_in_line_352 = sizeof( boost::mpl::assertion_failed<((!is_char_array<T>::value))>( mpl_assert_arg352::assert_arg() ) ) };




    typedef typename wrap_cstr<T>::type container;

    typedef typename boost::mpl::eval_if<
        C
      , range_const_iterator<container>
      , range_mutable_iterator<container>
    >::type type;
};


template<typename T, typename C = boost::mpl::false_>
struct foreach_reverse_iterator
{
# 383 "/usr/include/boost-1_42/boost/foreach.hpp"
    struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING; typedef struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING383 : boost::mpl::assert_ { static boost::mpl::failed ************ (IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING::************ assert_arg()) (T&) { return 0; } } mpl_assert_arg383; enum { mpl_assertion_in_line_383 = sizeof( boost::mpl::assertion_failed<((!is_char_array<T>::value))>( mpl_assert_arg383::assert_arg() ) ) };




    typedef typename wrap_cstr<T>::type container;

    typedef typename boost::mpl::eval_if<
        C
      , range_reverse_iterator<container const>
      , range_reverse_iterator<container>
    >::type type;
};

template<typename T, typename C = boost::mpl::false_>
struct foreach_reference
  : iterator_reference<typename foreach_iterator<T, C>::type>
{
};




template<typename T>
inline type2type<T> *encode_type(T &, boost::mpl::false_ *) { return 0; }

template<typename T>
inline type2type<T, const_> *encode_type(T const &, boost::mpl::true_ *) { return 0; }




inline bool set_false(bool &b)
{
    b = false;
    return false;
}




template<typename T>
inline T *&to_ptr(T const &)
{
    static T *t = 0;
    return t;
}
# 444 "/usr/include/boost-1_42/boost/foreach.hpp"
template<typename T>
inline T &derefof(T *t)
{


    return reinterpret_cast<T &>(
        *const_cast<char *>(
            reinterpret_cast<char const volatile *>(t)
        )
    );
}
# 466 "/usr/include/boost-1_42/boost/foreach.hpp"
template<typename T>
struct rvalue_probe
{
    struct private_type_ {};

    typedef typename boost::mpl::if_<
        boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T
    >::type value_type;
    operator value_type() { return *reinterpret_cast<value_type *>(this); }
    operator T &() const { return *reinterpret_cast<T *>(const_cast<rvalue_probe *>(this)); }
};

template<typename T>
rvalue_probe<T> const make_probe(T const &)
{
    return rvalue_probe<T>();
}
# 614 "/usr/include/boost-1_42/boost/foreach.hpp"
template<typename T>
inline auto_any<T> contain(T const &t, boost::mpl::true_ *)
{
    return t;
}

template<typename T>
inline auto_any<T *> contain(T &t, boost::mpl::false_ *)
{




    return boost::addressof(t);

}
# 643 "/usr/include/boost-1_42/boost/foreach.hpp"
template<typename T, typename C>
inline auto_any<typename foreach_iterator<T, C>::type>
begin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
{
    return boost::begin(auto_any_cast<T, C>(col));
}

template<typename T, typename C>
inline auto_any<typename foreach_iterator<T, C>::type>
begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
{
    typedef typename type2type<T, C>::type type;
    typedef typename foreach_iterator<T, C>::type iterator;
    return iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
}
# 669 "/usr/include/boost-1_42/boost/foreach.hpp"
template<typename T, typename C>
inline auto_any<T *>
begin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
{
    return auto_any_cast<T *, boost::mpl::false_>(col);
}





template<typename T, typename C>
inline auto_any<typename foreach_iterator<T, C>::type>
end(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
{
    return boost::end(auto_any_cast<T, C>(col));
}

template<typename T, typename C>
inline auto_any<typename foreach_iterator<T, C>::type>
end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
{
    typedef typename type2type<T, C>::type type;
    typedef typename foreach_iterator<T, C>::type iterator;
    return iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
}
# 706 "/usr/include/boost-1_42/boost/foreach.hpp"
template<typename T, typename C>
inline auto_any<int>
end(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
{
    return 0;
}





template<typename T, typename C>
inline bool done(auto_any_t cur, auto_any_t end, type2type<T, C> *)
{
    typedef typename foreach_iterator<T, C>::type iter_t;
    return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);
}


template<typename T, typename C>
inline bool done(auto_any_t cur, auto_any_t, type2type<T *, C> *)
{
    return ! *auto_any_cast<T *, boost::mpl::false_>(cur);
}





template<typename T, typename C>
inline void next(auto_any_t cur, type2type<T, C> *)
{
    typedef typename foreach_iterator<T, C>::type iter_t;
    ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
}




template<typename T, typename C>
inline typename foreach_reference<T, C>::type
deref(auto_any_t cur, type2type<T, C> *)
{
    typedef typename foreach_iterator<T, C>::type iter_t;
    return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
}




template<typename T, typename C>
inline auto_any<typename foreach_reverse_iterator<T, C>::type>
rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
{
    return boost::rbegin(auto_any_cast<T, C>(col));
}

template<typename T, typename C>
inline auto_any<typename foreach_reverse_iterator<T, C>::type>
rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
{
    typedef typename type2type<T, C>::type type;
    typedef typename foreach_reverse_iterator<T, C>::type iterator;
    return iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
}
# 782 "/usr/include/boost-1_42/boost/foreach.hpp"
template<typename T, typename C>
inline auto_any<reverse_iterator<T *> >
rbegin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
{
    T *p = auto_any_cast<T *, boost::mpl::false_>(col);
    while(0 != *p)
        ++p;
    return reverse_iterator<T *>(p);
}





template<typename T, typename C>
inline auto_any<typename foreach_reverse_iterator<T, C>::type>
rend(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
{
    return boost::rend(auto_any_cast<T, C>(col));
}

template<typename T, typename C>
inline auto_any<typename foreach_reverse_iterator<T, C>::type>
rend(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
{
    typedef typename type2type<T, C>::type type;
    typedef typename foreach_reverse_iterator<T, C>::type iterator;
    return iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
}
# 822 "/usr/include/boost-1_42/boost/foreach.hpp"
template<typename T, typename C>
inline auto_any<reverse_iterator<T *> >
rend(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
{
    return reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col));
}





template<typename T, typename C>
inline bool rdone(auto_any_t cur, auto_any_t end, type2type<T, C> *)
{
    typedef typename foreach_reverse_iterator<T, C>::type iter_t;
    return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);
}




template<typename T, typename C>
inline void rnext(auto_any_t cur, type2type<T, C> *)
{
    typedef typename foreach_reverse_iterator<T, C>::type iter_t;
    ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
}




template<typename T, typename C>
inline typename foreach_reference<T, C>::type
rderef(auto_any_t cur, type2type<T, C> *)
{
    typedef typename foreach_reverse_iterator<T, C>::type iter_t;
    return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
}

}
}
# 12 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp" 2



# 1 "/usr/include/boost-1_42/boost/python/stl_iterator.hpp" 1
# 10 "/usr/include/boost-1_42/boost/python/stl_iterator.hpp"
# 1 "/usr/include/boost-1_42/boost/python/object/stl_iterator_core.hpp" 1
# 11 "/usr/include/boost-1_42/boost/python/object/stl_iterator_core.hpp"
namespace boost { namespace python { namespace objects {

struct stl_input_iterator_impl
{
    stl_input_iterator_impl();
    stl_input_iterator_impl(boost::python::object const &ob);
    void increment();
    bool equal(stl_input_iterator_impl const &that) const;
    boost::python::handle<> const &current() const;
private:
    boost::python::object it_;
    boost::python::handle<> ob_;
};

}}}
# 11 "/usr/include/boost-1_42/boost/python/stl_iterator.hpp" 2



namespace boost { namespace python
{


template<typename ValueT>
struct stl_input_iterator
  : boost::iterator_facade<
        stl_input_iterator<ValueT>
      , ValueT
      , std::input_iterator_tag
      , ValueT
    >
{
    stl_input_iterator()
      : impl_()
    {
    }


    stl_input_iterator(boost::python::object const &ob)
      : impl_(ob)
    {
    }

private:
    friend class boost::iterator_core_access;

    void increment()
    {
        this->impl_.increment();
    }

    ValueT dereference() const
    {
        return extract<ValueT>(this->impl_.current().get())();
    }

    bool equal(stl_input_iterator<ValueT> const &that) const
    {
        return this->impl_.equal(that.impl_);
    }

    objects::stl_input_iterator_impl impl_;
};

}}
# 16 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp" 2

namespace boost { namespace python { namespace container_utils {

    template <typename Container>
    void
    extend_container(Container& container, object l)
    {
        typedef typename Container::value_type data_type;


        if (boost::foreach_detail_::auto_any_t



 _foreach_col30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        = boost::foreach_detail_::contain( (std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , (true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))) , (true ? 0 : boost::foreach_detail_::is_rvalue_( (true ? boost::foreach_detail_::make_probe(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) : (std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))), 0))) , boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)))))) {} else if (boost::foreach_detail_::auto_any_t



 _foreach_cur30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        = boost::foreach_detail_::begin(



 _foreach_col30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        , (true ? 0 : boost::foreach_detail_::encode_type(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ), boost::foreach_detail_::is_const_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )))) , (true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))) , (true ? 0 : boost::foreach_detail_::is_rvalue_( (true ? boost::foreach_detail_::make_probe(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) : (std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))), 0))) , boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)))))) {} else if (boost::foreach_detail_::auto_any_t



 _foreach_end30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        = boost::foreach_detail_::end(



 _foreach_col30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        , (true ? 0 : boost::foreach_detail_::encode_type(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ), boost::foreach_detail_::is_const_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )))) , (true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))) , (true ? 0 : boost::foreach_detail_::is_rvalue_( (true ? boost::foreach_detail_::make_probe(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) : (std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))), 0))) , boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)))))) {} else for (bool



 _foreach_continue30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        = true;



 _foreach_continue30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        && !boost::foreach_detail_::done(



 _foreach_cur30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        ,



 _foreach_end30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        , (true ? 0 : boost::foreach_detail_::encode_type(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ), boost::foreach_detail_::is_const_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )))));



 _foreach_continue30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        ? boost::foreach_detail_::next(



 _foreach_cur30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        , (true ? 0 : boost::foreach_detail_::encode_type(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ), boost::foreach_detail_::is_const_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))))) : (void)0) if (boost::foreach_detail_::set_false(



 _foreach_continue30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        )) {} else for (object elem = boost::foreach_detail_::deref(



 _foreach_cur30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        , (true ? 0 : boost::foreach_detail_::encode_type(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ), boost::foreach_detail_::is_const_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))))); !



 _foreach_continue30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        ;



 _foreach_continue30
# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
        = true)




        {
            extract<data_type const&> x(elem);

            if (x.check())
            {
                container.push_back(x());
            }
            else
            {

                extract<data_type> x(elem);
                if (x.check())
                {
                    container.push_back(x());
                }
                else
                {
                    PyErr_SetString(PyExc_TypeError, "Incompatible Data Type");
                    throw_error_already_set();
                }
            }
        }
    }

}}}
# 34 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 2
# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/declare_qflags.hpp" 1
# 26 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/declare_qflags.hpp"
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 1
# 27 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/declare_qflags.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/declare_qflags.hpp" 2

namespace PySide
{

template< typename FLAG >
void __attribute__ ((visibility("internal"))) declare_qflags(const char *flag_name)
{
    boost::python::class_< FLAG >(flag_name, boost::python::init<const FLAG&>())
        .def(boost::python::init< boost::python::optional< int > >())
        .def(boost::python::init< typename FLAG::enum_type >())
        .def(boost::python::self & int())
        .def(boost::python::self == boost::python::self)
        .def(boost::python::self == int())
        .def(boost::python::self &= int())

        .def(int_(boost::python::self))

        .def(~boost::python::self)
        .def(boost::python::self |= boost::python::self)
        .def(boost::python::self ^= boost::python::self)
        .def(boost::python::self != boost::python::self)
        .def(!boost::python::self)
        .def(boost::python::self | boost::python::self)
        .def(boost::python::self ^ boost::python::self)

        ;


    boost::python::implicitly_convertible<int, FLAG >();
}

template< typename FLAG >
void __attribute__ ((visibility("internal"))) declare_int_qflags(const char *flag_name)
{
    boost::python::class_< FLAG >(flag_name, boost::python::init<const FLAG&>())
        .def(boost::python::init< boost::python::optional< int > >())
        .def(boost::python::init< typename FLAG::enum_type >())
        .def(boost::python::self & int())
        .def(boost::python::self &= int())

        .def(int_(boost::python::self))

        .def(~boost::python::self)
        .def(boost::python::self |= boost::python::self)
        .def(boost::python::self ^= boost::python::self)
        .def(!boost::python::self)
        .def(boost::python::self | boost::python::self)
        .def(boost::python::self ^ boost::python::self)

        ;


    boost::python::implicitly_convertible<typename FLAG::enum_type, FLAG >();
}

};
# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp" 1
# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp" 2


# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp" 1
# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp"
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/wrapper.hpp" 1
# 27 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/wrapper.hpp"
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/wrapper.hpp" 2


# 1 "/usr/include/qt4/QtCore/QStringList" 1
# 1 "/usr/include/qt4/QtCore/qstringlist.h" 1
# 1 "/usr/include/qt4/QtCore/QStringList" 2
# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/wrapper.hpp" 2

namespace PySide
{

class __attribute__ ((visibility("default"))) wrapper
{
    public:
        PyObject* py_object() { return m_self; }
        void keep_cpp_ref();
        virtual ~wrapper();

    protected:
        wrapper(PyObject *self);
        boost::python::object get_override(const char* base_class_name, const char* method_name) const;

    private:
        wrapper() {}
        wrapper(wrapper &) {}

        PyObject *m_self;
        bool m_has_cpp_ref;
};

}
# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp" 2

# 1 "/usr/include/qt4/QtCore/QHash" 1
# 1 "/usr/include/qt4/QtCore/qhash.h" 1
# 51 "/usr/include/qt4/QtCore/qhash.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

class QBitArray;
class QByteArray;
class QString;
class QStringRef;

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) & (~0U));
    } else {
        return uint(key & (~0U));
    }
}
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) & (~0U));
    } else {
        return uint(key & (~0U));
    }
}
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);
 uint qHash(const QStringRef &key);
 uint qHash(const QBitArray &key);





template <class T> inline uint qHash(const T *key)
{
    return qHash(reinterpret_cast<quintptr>(key));
}




template <typename T1, typename T2> inline uint qHash(const QPair<T1, T2> &key)
{
    uint h1 = qHash(key.first);
    uint h2 = qHash(key.second);
    return ((h1 << 16) | (h1 >> 16)) ^ h2;
}

struct QHashData
{
    struct Node {
        Node *next;
        uint h;
    };

    Node *fakeNext;
    Node **buckets;
    QBasicAtomicInt ref;
    int size;
    int nodeSize;
    short userNumBits;
    short numBits;
    int numBuckets;
    uint sharable : 1;
    uint strictAlignment : 1;
    uint reserved : 30;

    void *allocateNode();
    void *allocateNode(int nodeAlign);
    void freeNode(void *node);
    QHashData *detach_helper(void (*node_duplicate)(Node *, void *), int nodeSize);
    QHashData *detach_helper2(void (*node_duplicate)(Node *, void *), void (*node_delete)(Node *),
                              int nodeSize, int nodeAlign);
    void mightGrow();
    bool willGrow();
    void hasShrunk();
    void rehash(int hint);
    void free_helper(void (*node_delete)(Node *));
    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 bool QHashData::willGrow()
{
    if (size >= numBuckets) {
        rehash(numBits + 1);
        return true;
    } else {
        return false;
    }
}

inline void QHashData::hasShrunk()
{
    if (size <= (numBuckets >> 3) && numBits > userNumBits) {
        try {
            rehash(qMax(int(numBits) - 2, int(userNumBits)));
        } catch (const std::bad_alloc &) {

        }
    }
}

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; }
};
# 250 "/usr/include/qt4/QtCore/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);
    }


    static inline int alignOfNode() { return qMax<int>(sizeof(void*), __alignof__(Node)); }
    static inline int alignOfDummyNode() { return qMax<int>(sizeof(void*), __alignof__(DummyNode)); }





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 Key key(const T &value, const Key &defaultKey) 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> uniqueKeys() 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
    {
        friend class const_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 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; }





    public:

        inline bool operator==(const const_iterator &o) const
            { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const
            { return i != o.i; }

    private:

        inline operator bool() const { return false; }
    };
    friend class iterator;

    class const_iterator
    {
        friend class 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 = 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; }
# 452 "/usr/include/qt4/QtCore/qhash.h"
    private:

        inline operator bool() const { return false; }
    };
    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);


    typedef T mapped_type;
    typedef Key key_type;
    typedef ptrdiff_t difference_type;
    typedef int size_type;

    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 deleteNode2(QHashData::Node *node);

    static void duplicateNode(QHashData::Node *originalNode, void *newNode);
};


template <class Key, class T>
inline void QHash<Key, T>::deleteNode(Node *node)
{
    deleteNode2(reinterpret_cast<QHashData::Node*>(node));
    d->freeNode(node);
}

template <class Key, class T>
inline void QHash<Key, T>::deleteNode2(QHashData::Node *node)
{





    concrete(node)->~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(alignOfDummyNode())) DummyNode(akey));
    } else {
        node = new (d->allocateNode(alignOfNode())) 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)
{
    x->free_helper(deleteNode2);
}

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()
{
    QHashData *x = d->detach_helper2(duplicateNode, deleteNode2,
        QTypeInfo<T>::isDummy ? sizeof(DummyNode) : sizeof(Node),
        QTypeInfo<T>::isDummy ? alignOfDummyNode() : alignOfNode());
    if (!d->ref.deref())
        freeData(d);
    d = x;
}

template <class Key, class T>
inline QHash<Key, T> &QHash<Key, T>::operator=(const QHash<Key, T> &other)
{
    if (d != other.d) {
        other.d->ref.ref();
        if (!d->ref.deref())
            freeData(d);
        d = other.d;
        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;
    if (d->size == 0 || (node = *findNode(akey)) == 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;
    if (d->size == 0 || (node = *findNode(akey)) == e) {
        return adefaultValue;
    } else {
        return node->value;
    }
}

template <class Key, class T>
 QList<Key> QHash<Key, T>::uniqueKeys() const
{
    QList<Key> res;
    const_iterator i = begin();
    if (i != end()) {
        for (;;) {
            const Key &aKey = i.key();
            res.append(aKey);
            do {
                if (++i == end())
                    goto break_out_of_outer_loop;
            } while (aKey == i.key());
        }
    }
break_out_of_outer_loop:
    return res;
}

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
{
    return key(avalue, Key());
}

template <class Key, class T>
 const Key QHash<Key, T>::key(const T &avalue, const Key &defaultValue) const
{
    const_iterator i = begin();
    while (i != end()) {
        if (i.value() == avalue)
            return i.key();
        ++i;
    }

    return defaultValue;
}

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();

    uint h;
    Node **node = findNode(akey, &h);
    if (*node == e) {
        if (d->willGrow())
            node = findNode(akey, &h);
        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();

    uint h;
    Node **node = findNode(akey, &h);
    if (*node == e) {
        if (d->willGrow())
            node = findNode(akey, &h);
        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->willGrow();

    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)
{
    if (isEmpty())
        return 0;
    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)
{
    if (isEmpty())
        return T();
    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]);
        ((!(*node == e || (*node)->next)) ? qt_assert("*node == e || (*node)->next","/usr/include/qt4/QtCore/qhash.h",879) : qt_noop());
        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)
    { return QHash<Key, T>::insert(key, value); }

    inline typename QHash<Key, T>::iterator insert(const Key &key, const T &value)
    { return QHash<Key, T>::insertMulti(key, 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; }



    using QHash<Key, T>::contains;
    using QHash<Key, T>::remove;
    using QHash<Key, T>::count;
    using QHash<Key, T>::find;
    using QHash<Key, T>::constFind;
# 958 "/usr/include/qt4/QtCore/qhash.h"
    bool contains(const Key &key, const T &value) const;

    int remove(const Key &key, const T &value);

    int count(const Key &key, const T &value) const;

    typename QHash<Key, T>::iterator find(const Key &key, const T &value) {
        typename QHash<Key, T>::iterator i(find(key));
        typename QHash<Key, T>::iterator end(this->end());
        while (i != end && i.key() == key) {
            if (i.value() == value)
                return i;
            ++i;
        }
        return end;
    }
    typename QHash<Key, T>::const_iterator find(const Key &key, const T &value) const {
        typename QHash<Key, T>::const_iterator i(constFind(key));
        typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd());
        while (i != end && i.key() == key) {
            if (i.value() == value)
                return i;
            ++i;
        }
        return end;
    }
    typename QHash<Key, T>::const_iterator constFind(const Key &key, const T &value) const
        { return find(key, value); }
private:
    T &operator[](const Key &key);
    const T operator[](const Key &key) const;
};

template <class Key, class T>
inline bool QMultiHash<Key, T>::contains(const Key &key, const T &value) const
{
    return constFind(key, value) != QHash<Key, T>::constEnd();
}

template <class Key, class T>
inline int QMultiHash<Key, T>::remove(const Key &key, const T &value)
{
    int n = 0;
    typename QHash<Key, T>::iterator i(find(key));
    typename QHash<Key, T>::iterator end(QHash<Key, T>::end());
    while (i != end && i.key() == key) {
        if (i.value() == value) {




            i = erase(i);

            ++n;
        } else {
            ++i;
        }
    }
    return n;
}

template <class Key, class T>
inline int QMultiHash<Key, T>::count(const Key &key, const T &value) const
{
    int n = 0;
    typename QHash<Key, T>::const_iterator i(constFind(key));
    typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd());
    while (i != end && i.key() == key) {
        if (i.value() == value)
            ++n;
        ++i;
    }
    return n;
}

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 { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qhash.h",1033) : qt_noop()); return *n; } inline const Key &key() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qhash.h",1033) : qt_noop()); 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 typename QHash<Key,T>::const_iterator const_iterator; typedef iterator Item; QHash<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(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 const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qhash.h",1034) : qt_noop()); return *n; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qhash.h",1034) : qt_noop()); return *n; } inline const Key &key() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qhash.h",1034) : qt_noop()); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } };




# 1 "/usr/include/qt4/QtCore/QHash" 2
# 32 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp" 2
# 1 "/usr/include/qt4/QtCore/QDebug" 1
# 1 "/usr/include/qt4/QtCore/qdebug.h" 1
# 46 "/usr/include/qt4/QtCore/qdebug.h"
# 1 "/usr/include/qt4/QtCore/qhash.h" 1
# 47 "/usr/include/qt4/QtCore/qdebug.h" 2

# 1 "/usr/include/qt4/QtCore/qmap.h" 1
# 55 "/usr/include/qt4/QtCore/qmap.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

struct QMapData
{
    struct Node {
        Node *backward;
        Node *forward[1];
    };
    enum { LastLevel = 11, Sparseness = 3 };

    QMapData *backward;
    QMapData *forward[QMapData::LastLevel + 1];
    QBasicAtomicInt ref;
    int topLevel;
    int size;
    uint randomBits;
    uint insertInOrder : 1;
    uint sharable : 1;
    uint strictAlignment : 1;
    uint reserved : 29;

    static QMapData *createData();
    static QMapData *createData(int alignment);
    void continueFreeData(int offset);
    Node *node_create(Node *update[], int offset);
    Node *node_create(Node *update[], int offset, int alignment);
    void node_delete(Node *update[], int offset, Node *node);





    static QMapData shared_null;
};
# 105 "/usr/include/qt4/QtCore/qmap.h"
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)
{
    ((!(sizeof(quintptr) == sizeof(Ptr *))) ? qt_assert("sizeof(quintptr) == sizeof(Ptr *)","/usr/include/qt4/QtCore/qmap.h",113) : qt_noop());
    return quintptr(key1) < quintptr(key2);
}

template <class Ptr> inline bool qMapLessThanKey(const Ptr *key1, const Ptr *key2)
{
    ((!(sizeof(quintptr) == sizeof(const Ptr *))) ? qt_assert("sizeof(quintptr) == sizeof(const Ptr *)","/usr/include/qt4/QtCore/qmap.h",119) : qt_noop());
    return quintptr(key1) < quintptr(key2);
}


template <class Key, class T>
struct QMapNode {
    Key key;
    T value;
    QMapData::Node *backward;
    QMapData::Node *forward[1];
};

template <class Key, class T>
struct QMapPayloadNode
{
    Key key;
    T value;
    QMapData::Node *backward;
};

template <class Key, class T>
class QMap
{
    typedef QMapNode<Key, T> Node;
    typedef QMapPayloadNode<Key, T> PayloadNode;

    union {
        QMapData *d;
        QMapData::Node *e;
    };

    static inline int payload() { return sizeof(PayloadNode) - sizeof(QMapData::Node *); }
    static inline int alignment() {

        return int(qMax(sizeof(void*), __alignof__(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; }
    inline void setInsertInOrder(bool ordered) { d->insertInOrder = ordered; }

    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 Key key(const T &value, const Key &defaultKey) 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> uniqueKeys() 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
    {
        friend class const_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 &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 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; }





    public:

        inline bool operator==(const const_iterator &o) const
            { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const
            { return i != o.i; }

    private:

        inline operator bool() const { return false; }
    };
    friend class iterator;

    class const_iterator
    {
        friend class 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 = 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 = 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; }
# 341 "/usr/include/qt4/QtCore/qmap.h"
    private:

        inline operator bool() const { return false; }
    };
    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);






    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 insertMulti(const Key &key, const T &value);



    QMap<Key, T> &unite(const QMap<Key, T> &other);


    typedef Key key_type;
    typedef T mapped_type;
    typedef ptrdiff_t difference_type;
    typedef int size_type;
    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 Key, class T>
inline QMap<Key, T> &QMap<Key, T>::operator=(const QMap<Key, T> &other)
{
    if (d != other.d) {
        other.d->ref.ref();
        if (!d->ref.deref())
            freeData(d);
        d = other.d;
        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(), alignment());
    try {
        Node *concreteNode = concrete(abstractNode);
        new (&concreteNode->key) Key(akey);
        try {
            new (&concreteNode->value) T(avalue);
        } catch (...) {
            concreteNode->key.~Key();
            throw;
        }
    } catch (...) {
        adt->node_delete(aupdate, payload(), abstractNode);
        throw;
    }
# 452 "/usr/include/qt4/QtCore/qmap.h"
    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;
    if (d->size == 0 || (node = findNode(akey)) == 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;
    if (d->size == 0 || (node = findNode(akey)) == 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);
}
# 569 "/usr/include/qt4/QtCore/qmap.h"
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();
    const const_iterator b = copy.constBegin();
    while (it != b) {
        --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 *cur = x;
        QMapData *next = cur->forward[0];
        while (next != x) {
            cur = next;
            next = cur->forward[0];



            Node *concreteNode = concrete(reinterpret_cast<QMapData::Node *>(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(alignment());
    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) {
            try {
                Node *concreteNode = concrete(cur);
                node_create(x.d, update, concreteNode->key, concreteNode->value);
            } catch (...) {
                freeData(x.d);
                throw;
            }
            cur = cur->forward[0];
        }
        x.d->insertInOrder = false;
    }
    if (!d->ref.deref())
        freeData(d);
    d = 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>::uniqueKeys() const
{
    QList<Key> res;
    const_iterator i = begin();
    if (i != end()) {
        for (;;) {
            const Key &aKey = i.key();
            res.append(aKey);
            do {
                if (++i == end())
                    goto break_out_of_outer_loop;
            } while (!(aKey < i.key()));
        }
    }
break_out_of_outer_loop:
    return res;
}

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
{
    return key(avalue, Key());
}

template <class Key, class T>
 const Key QMap<Key, T>::key(const T &avalue, const Key &defaultKey) const
{
    const_iterator i = begin();
    while (i != end()) {
        if (i.value() == avalue)
            return i.key();
        ++i;
    }

    return defaultKey;
}

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(alignment());
    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)
    { return QMap<Key, T>::insert(key, value); }
    inline typename QMap<Key, T>::iterator insert(const Key &key, const T &value)
    { return QMap<Key, T>::insertMulti(key, 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; }



    using QMap<Key, T>::contains;
    using QMap<Key, T>::remove;
    using QMap<Key, T>::count;
    using QMap<Key, T>::find;
    using QMap<Key, T>::constFind;
# 984 "/usr/include/qt4/QtCore/qmap.h"
    bool contains(const Key &key, const T &value) const;

    int remove(const Key &key, const T &value);

    int count(const Key &key, const T &value) const;

    typename QMap<Key, T>::iterator find(const Key &key, const T &value) {
        typename QMap<Key, T>::iterator i(find(key));
        typename QMap<Key, T>::iterator end(this->end());
        while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
            if (i.value() == value)
                return i;
            ++i;
        }
        return end;
    }
    typename QMap<Key, T>::const_iterator find(const Key &key, const T &value) const {
        typename QMap<Key, T>::const_iterator i(constFind(key));
        typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
        while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
            if (i.value() == value)
                return i;
            ++i;
        }
        return end;
    }
    typename QMap<Key, T>::const_iterator constFind(const Key &key, const T &value) const
        { return find(key, value); }
private:
    T &operator[](const Key &key);
    const T operator[](const Key &key) const;
};

template <class Key, class T>
inline bool QMultiMap<Key, T>::contains(const Key &key, const T &value) const
{
    return constFind(key, value) != QMap<Key, T>::constEnd();
}

template <class Key, class T>
inline int QMultiMap<Key, T>::remove(const Key &key, const T &value)
{
    int n = 0;
    typename QMap<Key, T>::iterator i(find(key));
    typename QMap<Key, T>::iterator end(QMap<Key, T>::end());
    while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
        if (i.value() == value) {




            i = erase(i);

            ++n;
        } else {
            ++i;
        }
    }
    return n;
}

template <class Key, class T>
inline int QMultiMap<Key, T>::count(const Key &key, const T &value) const
{
    int n = 0;
    typename QMap<Key, T>::const_iterator i(constFind(key));
    typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
    while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
        if (i.value() == value)
            ++n;
        ++i;
    }
    return n;
}

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 { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qmap.h",1059) : qt_noop()); return *n; } inline const Key &key() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qmap.h",1059) : qt_noop()); 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 typename QMap<Key,T>::const_iterator const_iterator; typedef iterator Item; QMap<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(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 const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qmap.h",1060) : qt_noop()); return *n; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qmap.h",1060) : qt_noop()); return *n; } inline const Key &key() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qmap.h",1060) : qt_noop()); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } };




# 49 "/usr/include/qt4/QtCore/qdebug.h" 2

# 1 "/usr/include/qt4/QtCore/qtextstream.h" 1
# 48 "/usr/include/qt4/QtCore/qtextstream.h"
# 1 "/usr/include/qt4/QtCore/qlocale.h" 1
# 48 "/usr/include/qt4/QtCore/qlocale.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

class QDataStream;
class QDate;
class QDateTime;
class QTime;
class QVariant;
class QTextStream;
class QTextStreamPrivate;

class QLocale;


class QSystemLocale
{
public:
    QSystemLocale();
    virtual ~QSystemLocale();

    enum QueryType {
        LanguageId,
        CountryId,
        DecimalPoint,
        GroupSeparator,
        ZeroDigit,
        NegativeSign,
        DateFormatLong,
        DateFormatShort,
        TimeFormatLong,
        TimeFormatShort,
        DayNameLong,
        DayNameShort,
        MonthNameLong,
        MonthNameShort,
        DateToStringLong,
        DateToStringShort,
        TimeToStringLong,
        TimeToStringShort,
        DateTimeFormatLong,
        DateTimeFormatShort,
        DateTimeToStringLong,
        DateTimeToStringShort,
        MeasurementSystem,
        PositiveSign,
        AMText,
        PMText
    };
    virtual QVariant query(QueryType type, QVariant in) const;
    virtual QLocale fallbackLocale() const;

private:
    QSystemLocale(bool);
    friend QSystemLocale *QSystemLocale_globalSystemLocale();
};


struct QLocalePrivate;
class QLocale
{
    public: static const QMetaObject staticMetaObject; private:
   
   
    friend class QString;
    friend class QByteArray;
    friend class QIntValidator;
    friend class QDoubleValidator;
    friend class QTextStream;
    friend class QTextStreamPrivate;

public:
    enum Language {
        C = 1,
        Abkhazian = 2,
        Afan = 3,
        Afar = 4,
        Afrikaans = 5,
        Albanian = 6,
        Amharic = 7,
        Arabic = 8,
        Armenian = 9,
        Assamese = 10,
        Aymara = 11,
        Azerbaijani = 12,
        Bashkir = 13,
        Basque = 14,
        Bengali = 15,
        Bhutani = 16,
        Bihari = 17,
        Bislama = 18,
        Breton = 19,
        Bulgarian = 20,
        Burmese = 21,
        Byelorussian = 22,
        Cambodian = 23,
        Catalan = 24,
        Chinese = 25,
        Corsican = 26,
        Croatian = 27,
        Czech = 28,
        Danish = 29,
        Dutch = 30,
        English = 31,
        Esperanto = 32,
        Estonian = 33,
        Faroese = 34,
        FijiLanguage = 35,
        Finnish = 36,
        French = 37,
        Frisian = 38,
        Gaelic = 39,
        Galician = 40,
        Georgian = 41,
        German = 42,
        Greek = 43,
        Greenlandic = 44,
        Guarani = 45,
        Gujarati = 46,
        Hausa = 47,
        Hebrew = 48,
        Hindi = 49,
        Hungarian = 50,
        Icelandic = 51,
        Indonesian = 52,
        Interlingua = 53,
        Interlingue = 54,
        Inuktitut = 55,
        Inupiak = 56,
        Irish = 57,
        Italian = 58,
        Japanese = 59,
        Javanese = 60,
        Kannada = 61,
        Kashmiri = 62,
        Kazakh = 63,
        Kinyarwanda = 64,
        Kirghiz = 65,
        Korean = 66,
        Kurdish = 67,
        Kurundi = 68,
        Laothian = 69,
        Latin = 70,
        Latvian = 71,
        Lingala = 72,
        Lithuanian = 73,
        Macedonian = 74,
        Malagasy = 75,
        Malay = 76,
        Malayalam = 77,
        Maltese = 78,
        Maori = 79,
        Marathi = 80,
        Moldavian = 81,
        Mongolian = 82,
        NauruLanguage = 83,
        Nepali = 84,
        Norwegian = 85,
        NorwegianBokmal = Norwegian,
        Occitan = 86,
        Oriya = 87,
        Pashto = 88,
        Persian = 89,
        Polish = 90,
        Portuguese = 91,
        Punjabi = 92,
        Quechua = 93,
        RhaetoRomance = 94,
        Romanian = 95,
        Russian = 96,
        Samoan = 97,
        Sangho = 98,
        Sanskrit = 99,
        Serbian = 100,
        SerboCroatian = 101,
        Sesotho = 102,
        Setswana = 103,
        Shona = 104,
        Sindhi = 105,
        Singhalese = 106,
        Siswati = 107,
        Slovak = 108,
        Slovenian = 109,
        Somali = 110,
        Spanish = 111,
        Sundanese = 112,
        Swahili = 113,
        Swedish = 114,
        Tagalog = 115,
        Tajik = 116,
        Tamil = 117,
        Tatar = 118,
        Telugu = 119,
        Thai = 120,
        Tibetan = 121,
        Tigrinya = 122,
        TongaLanguage = 123,
        Tsonga = 124,
        Turkish = 125,
        Turkmen = 126,
        Twi = 127,
        Uigur = 128,
        Ukrainian = 129,
        Urdu = 130,
        Uzbek = 131,
        Vietnamese = 132,
        Volapuk = 133,
        Welsh = 134,
        Wolof = 135,
        Xhosa = 136,
        Yiddish = 137,
        Yoruba = 138,
        Zhuang = 139,
        Zulu = 140,
        NorwegianNynorsk = 141,
        Nynorsk = NorwegianNynorsk,
        Bosnian = 142,
        Divehi = 143,
        Manx = 144,
        Cornish = 145,
        Akan = 146,
        Konkani = 147,
        Ga = 148,
        Igbo = 149,
        Kamba = 150,
        Syriac = 151,
        Blin = 152,
        Geez = 153,
        Koro = 154,
        Sidamo = 155,
        Atsam = 156,
        Tigre = 157,
        Jju = 158,
        Friulian = 159,
        Venda = 160,
        Ewe = 161,
        Walamo = 162,
        Hawaiian = 163,
        Tyap = 164,
        Chewa = 165,
        LastLanguage = Chewa
    };

    enum Country {
        AnyCountry = 0,
        Afghanistan = 1,
        Albania = 2,
        Algeria = 3,
        AmericanSamoa = 4,
        Andorra = 5,
        Angola = 6,
        Anguilla = 7,
        Antarctica = 8,
        AntiguaAndBarbuda = 9,
        Argentina = 10,
        Armenia = 11,
        Aruba = 12,
        Australia = 13,
        Austria = 14,
        Azerbaijan = 15,
        Bahamas = 16,
        Bahrain = 17,
        Bangladesh = 18,
        Barbados = 19,
        Belarus = 20,
        Belgium = 21,
        Belize = 22,
        Benin = 23,
        Bermuda = 24,
        Bhutan = 25,
        Bolivia = 26,
        BosniaAndHerzegowina = 27,
        Botswana = 28,
        BouvetIsland = 29,
        Brazil = 30,
        BritishIndianOceanTerritory = 31,
        BruneiDarussalam = 32,
        Bulgaria = 33,
        BurkinaFaso = 34,
        Burundi = 35,
        Cambodia = 36,
        Cameroon = 37,
        Canada = 38,
        CapeVerde = 39,
        CaymanIslands = 40,
        CentralAfricanRepublic = 41,
        Chad = 42,
        Chile = 43,
        China = 44,
        ChristmasIsland = 45,
        CocosIslands = 46,
        Colombia = 47,
        Comoros = 48,
        DemocraticRepublicOfCongo = 49,
        PeoplesRepublicOfCongo = 50,
        CookIslands = 51,
        CostaRica = 52,
        IvoryCoast = 53,
        Croatia = 54,
        Cuba = 55,
        Cyprus = 56,
        CzechRepublic = 57,
        Denmark = 58,
        Djibouti = 59,
        Dominica = 60,
        DominicanRepublic = 61,
        EastTimor = 62,
        Ecuador = 63,
        Egypt = 64,
        ElSalvador = 65,
        EquatorialGuinea = 66,
        Eritrea = 67,
        Estonia = 68,
        Ethiopia = 69,
        FalklandIslands = 70,
        FaroeIslands = 71,
        FijiCountry = 72,
        Finland = 73,
        France = 74,
        MetropolitanFrance = 75,
        FrenchGuiana = 76,
        FrenchPolynesia = 77,
        FrenchSouthernTerritories = 78,
        Gabon = 79,
        Gambia = 80,
        Georgia = 81,
        Germany = 82,
        Ghana = 83,
        Gibraltar = 84,
        Greece = 85,
        Greenland = 86,
        Grenada = 87,
        Guadeloupe = 88,
        Guam = 89,
        Guatemala = 90,
        Guinea = 91,
        GuineaBissau = 92,
        Guyana = 93,
        Haiti = 94,
        HeardAndMcDonaldIslands = 95,
        Honduras = 96,
        HongKong = 97,
        Hungary = 98,
        Iceland = 99,
        India = 100,
        Indonesia = 101,
        Iran = 102,
        Iraq = 103,
        Ireland = 104,
        Israel = 105,
        Italy = 106,
        Jamaica = 107,
        Japan = 108,
        Jordan = 109,
        Kazakhstan = 110,
        Kenya = 111,
        Kiribati = 112,
        DemocraticRepublicOfKorea = 113,
        RepublicOfKorea = 114,
        Kuwait = 115,
        Kyrgyzstan = 116,
        Lao = 117,
        Latvia = 118,
        Lebanon = 119,
        Lesotho = 120,
        Liberia = 121,
        LibyanArabJamahiriya = 122,
        Liechtenstein = 123,
        Lithuania = 124,
        Luxembourg = 125,
        Macau = 126,
        Macedonia = 127,
        Madagascar = 128,
        Malawi = 129,
        Malaysia = 130,
        Maldives = 131,
        Mali = 132,
        Malta = 133,
        MarshallIslands = 134,
        Martinique = 135,
        Mauritania = 136,
        Mauritius = 137,
        Mayotte = 138,
        Mexico = 139,
        Micronesia = 140,
        Moldova = 141,
        Monaco = 142,
        Mongolia = 143,
        Montserrat = 144,
        Morocco = 145,
        Mozambique = 146,
        Myanmar = 147,
        Namibia = 148,
        NauruCountry = 149,
        Nepal = 150,
        Netherlands = 151,
        NetherlandsAntilles = 152,
        NewCaledonia = 153,
        NewZealand = 154,
        Nicaragua = 155,
        Niger = 156,
        Nigeria = 157,
        Niue = 158,
        NorfolkIsland = 159,
        NorthernMarianaIslands = 160,
        Norway = 161,
        Oman = 162,
        Pakistan = 163,
        Palau = 164,
        PalestinianTerritory = 165,
        Panama = 166,
        PapuaNewGuinea = 167,
        Paraguay = 168,
        Peru = 169,
        Philippines = 170,
        Pitcairn = 171,
        Poland = 172,
        Portugal = 173,
        PuertoRico = 174,
        Qatar = 175,
        Reunion = 176,
        Romania = 177,
        RussianFederation = 178,
        Rwanda = 179,
        SaintKittsAndNevis = 180,
        StLucia = 181,
        StVincentAndTheGrenadines = 182,
        Samoa = 183,
        SanMarino = 184,
        SaoTomeAndPrincipe = 185,
        SaudiArabia = 186,
        Senegal = 187,
        Seychelles = 188,
        SierraLeone = 189,
        Singapore = 190,
        Slovakia = 191,
        Slovenia = 192,
        SolomonIslands = 193,
        Somalia = 194,
        SouthAfrica = 195,
        SouthGeorgiaAndTheSouthSandwichIslands = 196,
        Spain = 197,
        SriLanka = 198,
        StHelena = 199,
        StPierreAndMiquelon = 200,
        Sudan = 201,
        Suriname = 202,
        SvalbardAndJanMayenIslands = 203,
        Swaziland = 204,
        Sweden = 205,
        Switzerland = 206,
        SyrianArabRepublic = 207,
        Taiwan = 208,
        Tajikistan = 209,
        Tanzania = 210,
        Thailand = 211,
        Togo = 212,
        Tokelau = 213,
        TongaCountry = 214,
        TrinidadAndTobago = 215,
        Tunisia = 216,
        Turkey = 217,
        Turkmenistan = 218,
        TurksAndCaicosIslands = 219,
        Tuvalu = 220,
        Uganda = 221,
        Ukraine = 222,
        UnitedArabEmirates = 223,
        UnitedKingdom = 224,
        UnitedStates = 225,
        UnitedStatesMinorOutlyingIslands = 226,
        Uruguay = 227,
        Uzbekistan = 228,
        Vanuatu = 229,
        VaticanCityState = 230,
        Venezuela = 231,
        VietNam = 232,
        BritishVirginIslands = 233,
        USVirginIslands = 234,
        WallisAndFutunaIslands = 235,
        WesternSahara = 236,
        Yemen = 237,
        Yugoslavia = 238,
        Zambia = 239,
        Zimbabwe = 240,
        SerbiaAndMontenegro = 241,
        LastCountry = SerbiaAndMontenegro
    };

    enum MeasurementSystem { MetricSystem, ImperialSystem };

    enum FormatType { LongFormat, ShortFormat, NarrowFormat };
    enum NumberOption {
        OmitGroupSeparator = 0x01,
        RejectGroupSeparator = 0x02
    };
    typedef QFlags<NumberOption> NumberOptions;

    QLocale();
    QLocale(const QString &name);
    QLocale(Language language, Country country = AnyCountry);
    QLocale(const QLocale &other);

    QLocale &operator=(const QLocale &other);

    Language language() const;
    Country country() const;
    QString name() const;

    short toShort(const QString &s, bool *ok = 0, int base = 0) const;
    ushort toUShort(const QString &s, bool *ok = 0, int base = 0) const;
    int toInt(const QString &s, bool *ok = 0, int base = 0) const;
    uint toUInt(const QString &s, bool *ok = 0, int base = 0) const;
    qlonglong toLongLong(const QString &s, bool *ok = 0, int base = 0) const;
    qlonglong toULongLong(const QString &s, bool *ok = 0, int base = 0) const;
    float toFloat(const QString &s, bool *ok = 0) const;
    double toDouble(const QString &s, bool *ok = 0) const;

    QString toString(qlonglong i) const;
    QString toString(qulonglong i) const;
    inline QString toString(short i) const;
    inline QString toString(ushort i) const;
    inline QString toString(int i) const;
    inline QString toString(uint i) const;
    QString toString(double i, char f = 'g', int prec = 6) const;
    inline QString toString(float i, char f = 'g', int prec = 6) const;
    QString toString(const QDate &date, const QString &formatStr) const;
    QString toString(const QDate &date, FormatType format = LongFormat) const;
    QString toString(const QTime &time, const QString &formatStr) const;
    QString toString(const QTime &time, FormatType format = LongFormat) const;
    QString toString(const QDateTime &dateTime, FormatType format = LongFormat) const;
    QString toString(const QDateTime &dateTime, const QString &format) const;

    QString dateFormat(FormatType format = LongFormat) const;
    QString timeFormat(FormatType format = LongFormat) const;
    QString dateTimeFormat(FormatType format = LongFormat) const;

    QDate toDate(const QString &string, FormatType = LongFormat) const;
    QTime toTime(const QString &string, FormatType = LongFormat) const;
    QDateTime toDateTime(const QString &string, FormatType format = LongFormat) const;
    QDate toDate(const QString &string, const QString &format) const;
    QTime toTime(const QString &string, const QString &format) const;
    QDateTime toDateTime(const QString &string, const QString &format) const;




    QChar decimalPoint() const;
    QChar groupSeparator() const;
    QChar percent() const;
    QChar zeroDigit() const;
    QChar negativeSign() const;
    QChar positiveSign() const;
    QChar exponential() const;

    QString monthName(int, FormatType format = LongFormat) const;
    QString standaloneMonthName(int, FormatType format = LongFormat) const;
    QString dayName(int, FormatType format = LongFormat) const;
    QString standaloneDayName(int, FormatType format = LongFormat) const;

    QString amText() const;
    QString pmText() const;

    MeasurementSystem measurementSystem() const;

    inline bool operator==(const QLocale &other) const;
    inline bool operator!=(const QLocale &other) const;

    static QString languageToString(Language language);
    static QString countryToString(Country country);
    static void setDefault(const QLocale &locale);

    static QLocale c() { return QLocale(C); }
    static QLocale system();

    static QList<Country> countriesForLanguage(Language lang);

    void setNumberOptions(NumberOptions options);
    NumberOptions numberOptions() const;


    struct Data {
        quint16 index;
        quint16 numberOptions;
    }



        ;
private:
    friend struct QLocalePrivate;


    union {
        void *v;
        Data p;
    };
    const QLocalePrivate *d() const;
};
template <> class QTypeInfo<QLocale > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLocale)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLocale"; } };
inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QLocale::NumberOptions::enum_type f2) { return QFlags<QLocale::NumberOptions::enum_type>(f1) | f2; } inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QFlags<QLocale::NumberOptions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QLocale::NumberOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }

inline QString QLocale::toString(short i) const
    { return toString(qlonglong(i)); }
inline QString QLocale::toString(ushort i) const
    { return toString(qulonglong(i)); }
inline QString QLocale::toString(int i) const
    { return toString(qlonglong(i)); }
inline QString QLocale::toString(uint i) const
    { return toString(qulonglong(i)); }
inline QString QLocale::toString(float i, char f, int prec) const
    { return toString(double(i), f, prec); }
inline bool QLocale::operator==(const QLocale &other) const
    { return d() == other.d() && numberOptions() == other.numberOptions(); }
inline bool QLocale::operator!=(const QLocale &other) const
    { return d() != other.d() || numberOptions() != other.numberOptions(); }


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





# 49 "/usr/include/qt4/QtCore/qtextstream.h" 2
# 63 "/usr/include/qt4/QtCore/qtextstream.h"




typedef QtValidLicenseForCoreModule QtCoreModule;

class QTextCodec;
class QTextDecoder;

class QTextStreamPrivate;
class QTextStream
{
    inline QTextStreamPrivate* d_func() { return reinterpret_cast<QTextStreamPrivate *>(qGetPtrHelper(d_ptr)); } inline const QTextStreamPrivate* d_func() const { return reinterpret_cast<const QTextStreamPrivate *>(qGetPtrHelper(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 setLocale(const QLocale &locale);
    QLocale locale() 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);
    qint64 pos() const;

    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);
# 252 "/usr/include/qt4/QtCore/qtextstream.h"
private:





    QTextStream(const QTextStream &); QTextStream &operator=(const QTextStream &);

    QScopedPointer<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; } inline QIncompatibleFlag operator|(QTextStream::NumberFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }





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; arg = -1; }
    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);
}
# 372 "/usr/include/qt4/QtCore/qtextstream.h"



# 51 "/usr/include/qt4/QtCore/qdebug.h" 2


# 1 "/usr/include/qt4/QtCore/qset.h" 1
# 47 "/usr/include/qt4/QtCore/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 setSharable(bool sharable) { q_hash.setSharable(sharable); }

    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); }

    bool contains(const QSet<T> &set) const;

    class const_iterator;

    class iterator
    {
        typedef QHash<T, QHashDummyValue> Hash;
        typename Hash::iterator i;
        friend class const_iterator;

    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 iterator() {}
        inline iterator(typename Hash::iterator o) : i(o) {}
        inline iterator(const iterator &o) : i(o.i) {}
        inline iterator &operator=(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 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 == o.i; }
        inline bool operator!=(const const_iterator &o) const
            { return i != o.i; }
        inline iterator &operator++() { ++i; return *this; }
        inline iterator operator++(int) { iterator r = *this; ++i; return r; }
        inline iterator &operator--() { --i; return *this; }
        inline iterator operator--(int) { iterator r = *this; --i; return r; }
        inline iterator operator+(int j) const { return i + j; }
        inline iterator operator-(int j) const { return i - j; }
        inline iterator &operator+=(int j) { i += j; return *this; }
        inline iterator &operator-=(int j) { i -= j; return *this; }
    };

    class const_iterator
    {
        typedef QHash<T, QHashDummyValue> Hash;
        typename Hash::const_iterator i;
        friend class iterator;

    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(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 iterator begin() { return q_hash.begin(); }
    inline const_iterator begin() const { return q_hash.begin(); }
    inline const_iterator constBegin() const { return q_hash.constBegin(); }
    inline iterator end() { return q_hash.end(); }
    inline const_iterator end() const { return q_hash.end(); }
    inline const_iterator constEnd() const { return q_hash.constEnd(); }
    iterator erase(iterator i)
        { return q_hash.erase(reinterpret_cast<typename Hash::iterator &>(i)); }


    typedef iterator Iterator;
    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())); }
    iterator find(const T &value) { return q_hash.find(value); }
    const_iterator find(const T &value) const { return q_hash.find(value); }
    inline const_iterator constFind(const T &value) const { return find(value); }
    QSet<T> &unite(const QSet<T> &other);
    QSet<T> &intersect(const QSet<T> &other);
    QSet<T> &subtract(const QSet<T> &other);


    typedef T key_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;
    typedef ptrdiff_t difference_type;
    typedef int size_type;

    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) const
        { QSet<T> result = *this; result |= other; return result; }
    inline QSet<T> operator&(const QSet<T> &other) const
        { QSet<T> result = *this; result &= other; return result; }
    inline QSet<T> operator+(const QSet<T> &other) const
        { QSet<T> result = *this; result += other; return result; }
    inline QSet<T> operator-(const QSet<T> &other) const
        { 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; }
    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 <class T>
inline bool QSet<T>::contains(const QSet<T> &other) const
{
    typename QSet<T>::const_iterator i = other.constBegin();
    while (i != other.constEnd()) {
        if (!contains(*i))
            return false;
        ++i;
    }
    return true;
}

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; } };

template <typename T>
class QMutableSetIterator
{
    typedef typename QSet<T>::iterator iterator;
    QSet<T> *c;
    iterator i, n;
    inline bool item_exists() const { return n != c->constEnd(); }

public:
    inline QMutableSetIterator(QSet<T> &container)
        : c(&container)
    { c->setSharable(false); i = c->begin(); n = c->end(); }
    inline ~QMutableSetIterator()
    { c->setSharable(true); }
    inline QMutableSetIterator &operator=(QSet<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 const T &next() { n = i++; return *n; }
    inline const T &peekNext() const { return *i; }
    inline bool hasPrevious() const { return c->constBegin() != i; }
    inline const T &previous() { n = --i; return *n; }
    inline const T &peekPrevious() const { iterator p = i; return *--p; }
    inline void remove()
    { if (c->constEnd() != n) { i = c->erase(n); n = c->end(); } }
    inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qset.h",354) : qt_noop()); return *n; }
    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; }
};




# 54 "/usr/include/qt4/QtCore/qdebug.h" 2
# 1 "/usr/include/qt4/QtCore/qcontiguouscache.h" 1
# 46 "/usr/include/qt4/QtCore/qcontiguouscache.h"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
# 47 "/usr/include/qt4/QtCore/qcontiguouscache.h" 2







typedef QtValidLicenseForCoreModule QtCoreModule;


struct QContiguousCacheData
{
    QBasicAtomicInt ref;
    int alloc;
    int count;
    int start;
    int offset;
    uint sharable : 1;
    uint reserved : 31;






    static QContiguousCacheData *allocate(int size, int alignment);
    static void free(QContiguousCacheData *data);




};

template <typename T>
struct QContiguousCacheTypedData: private QContiguousCacheData
{

    T array[1];

    static inline void free(QContiguousCacheTypedData *data) { QContiguousCacheData::free(data); }
};

template<typename T>
class QContiguousCache {
    typedef QContiguousCacheTypedData<T> Data;
    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; };
public:

    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 int size_type;

    explicit QContiguousCache(int capacity = 0);
    QContiguousCache(const QContiguousCache<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }

    inline ~QContiguousCache() { if (!d) return; if (!d->ref.deref()) free(p); }

    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; }

    QContiguousCache<T> &operator=(const QContiguousCache<T> &other);
    bool operator==(const QContiguousCache<T> &other) const;
    inline bool operator!=(const QContiguousCache<T> &other) const { return !(*this == other); }

    inline int capacity() const {return d->alloc; }
    inline int count() const { return d->count; }
    inline int size() const { return d->count; }

    inline bool isEmpty() const { return d->count == 0; }
    inline bool isFull() const { return d->count == d->alloc; }
    inline int available() const { return d->alloc - d->count; }

    void clear();
    void setCapacity(int size);

    const T &at(int pos) const;
    T &operator[](int i);
    const T &operator[](int i) const;

    void append(const T &value);
    void prepend(const T &value);
    void insert(int pos, const T &value);

    inline bool containsIndex(int pos) const { return pos >= d->offset && pos - d->offset < d->count; }
    inline int firstIndex() const { return d->offset; }
    inline int lastIndex() const { return d->offset + d->count - 1; }

    inline const T &first() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qcontiguouscache.h",139) : qt_noop()); return p->array[d->start]; }
    inline const T &last() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qcontiguouscache.h",140) : qt_noop()); return p->array[(d->start + d->count -1) % d->alloc]; }
    inline T &first() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qcontiguouscache.h",141) : qt_noop()); detach(); return p->array[d->start]; }
    inline T &last() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qcontiguouscache.h",142) : qt_noop()); detach(); return p->array[(d->start + d->count -1) % d->alloc]; }

    void removeFirst();
    T takeFirst();
    void removeLast();
    T takeLast();

    inline bool areIndexesValid() const
    { return d->offset >= 0 && d->offset < 2147483647 - d->count && (d->offset % d->alloc) == d->start; }

    inline void normalizeIndexes() { d->offset = d->start; }




private:
    void detach_helper();

    QContiguousCacheData *malloc(int aalloc);
    void free(Data *x);
    int sizeOfTypedData() {


        return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
    }
    int alignOfTypedData() const
    {

        return qMax<int>(sizeof(void*), __alignof__(Data));



    }
};

template <typename T>
void QContiguousCache<T>::detach_helper()
{
    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;

    x.d = malloc(d->alloc);
    x.d->ref = 1;
    x.d->count = d->count;
    x.d->start = d->start;
    x.d->offset = d->offset;
    x.d->alloc = d->alloc;
    x.d->sharable = true;
    x.d->reserved = 0;

    T *dest = x.p->array + x.d->start;
    T *src = p->array + d->start;
    int oldcount = x.d->count;
    while (oldcount--) {
        if (QTypeInfo<T>::isComplex) {
            new (dest) T(*src);
        } else {
            *dest = *src;
        }
        dest++;
        if (dest == x.p->array + x.d->alloc)
            dest = x.p->array;
        src++;
        if (src == p->array + d->alloc)
            src = p->array;
    }

    if (!d->ref.deref())
        free(p);
    d = x.d;
}

template <typename T>
void QContiguousCache<T>::setCapacity(int asize)
{
    if (asize == d->alloc)
        return;
    detach();
    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
    x.d = malloc(asize);
    x.d->alloc = asize;
    x.d->count = qMin(d->count, asize);
    x.d->offset = d->offset + d->count - x.d->count;
    x.d->start = x.d->offset % x.d->alloc;
    T *dest = x.p->array + (x.d->start + x.d->count-1) % x.d->alloc;
    T *src = p->array + (d->start + d->count-1) % d->alloc;
    int oldcount = x.d->count;
    while (oldcount--) {
        if (QTypeInfo<T>::isComplex) {
            new (dest) T(*src);
        } else {
            *dest = *src;
        }
        if (dest == x.p->array)
            dest = x.p->array + x.d->alloc;
        dest--;
        if (src == p->array)
            src = p->array + d->alloc;
        src--;
    }

    free(p);
    d = x.d;
}

template <typename T>
void QContiguousCache<T>::clear()
{
    if (d->ref == 1) {
        if (QTypeInfo<T>::isComplex) {
            int oldcount = d->count;
            T * i = p->array + d->start;
            T * e = p->array + d->alloc;
            while (oldcount--) {
                i->~T();
                i++;
                if (i == e)
                    i = p->array;
            }
        }
        d->count = d->start = d->offset = 0;
    } else {
        union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
        x.d = malloc(d->alloc);
        x.d->ref = 1;
        x.d->alloc = d->alloc;
        x.d->count = x.d->start = x.d->offset = 0;
        x.d->sharable = true;
        if (!d->ref.deref()) free(p);
        d = x.d;
    }
}

template <typename T>
inline QContiguousCacheData *QContiguousCache<T>::malloc(int aalloc)
{
    return QContiguousCacheData::allocate(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData());
}

template <typename T>
QContiguousCache<T>::QContiguousCache(int cap)
{
    d = malloc(cap);
    d->ref = 1;
    d->alloc = cap;
    d->count = d->start = d->offset = 0;
    d->sharable = true;
}

template <typename T>
QContiguousCache<T> &QContiguousCache<T>::operator=(const QContiguousCache<T> &other)
{
    other.d->ref.ref();
    if (!d->ref.deref())
        free(d);
    d = other.d;
    if (!d->sharable)
        detach_helper();
    return *this;
}

template <typename T>
bool QContiguousCache<T>::operator==(const QContiguousCache<T> &other) const
{
    if (other.d == d)
        return true;
    if (other.d->start != d->start
            || other.d->count != d->count
            || other.d->offset != d->offset
            || other.d->alloc != d->alloc)
        return false;
    for (int i = firstIndex(); i <= lastIndex(); ++i)
        if (!(at(i) == other.at(i)))
            return false;
    return true;
}

template <typename T>
void QContiguousCache<T>::free(Data *x)
{
    if (QTypeInfo<T>::isComplex) {
        int oldcount = d->count;
        T * i = p->array + d->start;
        T * e = p->array + d->alloc;
        while (oldcount--) {
            i->~T();
            i++;
            if (i == e)
                i = p->array;
        }
    }
    x->free(x);
}
template <typename T>
void QContiguousCache<T>::append(const T &value)
{
    detach();
    if (QTypeInfo<T>::isComplex) {
        if (d->count == d->alloc)
            (p->array + (d->start+d->count) % d->alloc)->~T();
        new (p->array + (d->start+d->count) % d->alloc) T(value);
    } else {
        p->array[(d->start+d->count) % d->alloc] = value;
    }

    if (d->count == d->alloc) {
        d->start++;
        d->start %= d->alloc;
        d->offset++;
    } else {
        d->count++;
    }
}

template<typename T>
void QContiguousCache<T>::prepend(const T &value)
{
    detach();
    if (d->start)
        d->start--;
    else
        d->start = d->alloc-1;
    d->offset--;

    if (d->count != d->alloc)
        d->count++;
    else
        if (d->count == d->alloc)
            (p->array + d->start)->~T();

    if (QTypeInfo<T>::isComplex)
        new (p->array + d->start) T(value);
    else
        p->array[d->start] = value;
}

template<typename T>
void QContiguousCache<T>::insert(int pos, const T &value)
{
    ((!(pos >= 0 && pos < 2147483647)) ? qt_assert_x("QContiguousCache<T>::insert", "index out of range","/usr/include/qt4/QtCore/qcontiguouscache.h",380) : qt_noop());
    detach();
    if (containsIndex(pos)) {
        if(QTypeInfo<T>::isComplex)
            new (p->array + pos % d->alloc) T(value);
        else
            p->array[pos % d->alloc] = value;
    } else if (pos == d->offset-1)
        prepend(value);
    else if (pos == d->offset+d->count)
        append(value);
    else {

        clear();
        d->offset = pos;
        d->start = pos % d->alloc;
        d->count = 1;
        if (QTypeInfo<T>::isComplex)
            new (p->array + d->start) T(value);
        else
            p->array[d->start] = value;
    }
}

template <typename T>
inline const T &QContiguousCache<T>::at(int pos) const
{ ((!(pos >= d->offset && pos - d->offset < d->count)) ? qt_assert_x("QContiguousCache<T>::at", "index out of range","/usr/include/qt4/QtCore/qcontiguouscache.h",406) : qt_noop()); return p->array[pos % d->alloc]; }
template <typename T>
inline const T &QContiguousCache<T>::operator[](int pos) const
{ ((!(pos >= d->offset && pos - d->offset < d->count)) ? qt_assert_x("QContiguousCache<T>::at", "index out of range","/usr/include/qt4/QtCore/qcontiguouscache.h",409) : qt_noop()); return p->array[pos % d->alloc]; }

template <typename T>
inline T &QContiguousCache<T>::operator[](int pos)
{
    detach();
    if (!containsIndex(pos))
        insert(pos, T());
    return p->array[pos % d->alloc];
}

template <typename T>
inline void QContiguousCache<T>::removeFirst()
{
    ((!(d->count > 0)) ? qt_assert("d->count > 0","/usr/include/qt4/QtCore/qcontiguouscache.h",423) : qt_noop());
    detach();
    d->count--;
    if (QTypeInfo<T>::isComplex)
        (p->array + d->start)->~T();
    d->start = (d->start + 1) % d->alloc;
    d->offset++;
}

template <typename T>
inline void QContiguousCache<T>::removeLast()
{
    ((!(d->count > 0)) ? qt_assert("d->count > 0","/usr/include/qt4/QtCore/qcontiguouscache.h",435) : qt_noop());
    detach();
    d->count--;
    if (QTypeInfo<T>::isComplex)
        (p->array + (d->start + d->count) % d->alloc)->~T();
}

template <typename T>
inline T QContiguousCache<T>::takeFirst()
{ T t = first(); removeFirst(); return t; }

template <typename T>
inline T QContiguousCache<T>::takeLast()
{ T t = last(); removeLast(); return t; }




# 55 "/usr/include/qt4/QtCore/qdebug.h" 2





typedef QtValidLicenseForCoreModule QtCoreModule;

class QDebug
{
    struct Stream {
        Stream(QIODevice *device) : ts(device), ref(1), type(QtDebugMsg), space(true), message_output(false) {}
        Stream(QString *string) : ts(string, QIODevice::WriteOnly), ref(1), type(QtDebugMsg), space(true), message_output(false) {}
        Stream(QtMsgType t) : ts(&buffer, QIODevice::WriteOnly), ref(1), type(t), space(true), message_output(true) {}
        QTextStream ts;
        QString buffer;
        int ref;
        QtMsgType type;
        bool space;
        bool message_output;
    } *stream;
public:
    inline QDebug(QIODevice *device) : stream(new Stream(device)) {}
    inline QDebug(QString *string) : stream(new Stream(string)) {}
    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) {
            if(stream->message_output) {
                try {
                    qt_message_output(stream->type, stream->buffer.toLocal8Bit().data());
                } catch (std::bad_alloc&) { }
            }
            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<<(QBool t) { stream->ts << (bool(t != 0) ? "true" : "false"); 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 << QString::fromAscii(t); return maybeSpace(); }
    inline QDebug &operator<<(const QString & t) { stream->ts << '\"' << t << '\"'; return maybeSpace(); }
    inline QDebug &operator<<(const QStringRef & t) { return operator<<(t.toString()); }
    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; }
};

class QNoDebug
{
public:
    inline QNoDebug(){}
    inline QNoDebug(const QDebug &){}
    inline ~QNoDebug(){}

    inline QNoDebug &operator<<(QTextStreamFunction) { return *this; }
    inline QNoDebug &operator<<(QTextStreamManipulator) { return *this; }

    inline QNoDebug &space() { return *this; }
    inline QNoDebug &nospace() { return *this; }
    inline QNoDebug &maybeSpace() { return *this; }


    template<typename T>
    inline QNoDebug &operator<<(const T &) { return *this; }

};

 inline QDebug qCritical() { return QDebug(QtCriticalMsg); }

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)

{
    debug.nospace() << "QVector";
    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();
}

template <typename T>
inline QDebug operator<<(QDebug debug, const QSet<T> &set)
{
    debug.nospace() << "QSet";
    return operator<<(debug, set.toList());
}





template <class T>
inline QDebug operator<<(QDebug debug, const QContiguousCache<T> &cache)

{
    debug.nospace() << "QContiguousCache(";
    for (int i = cache.firstIndex(); i <= cache.lastIndex(); ++i) {
        debug << cache[i];
        if (i != cache.lastIndex())
            debug << ", ";
    }
    debug << ')';
    return debug.space();
}


 inline QDebug qDebug() { return QDebug(QtDebugMsg); }
# 273 "/usr/include/qt4/QtCore/qdebug.h"
 inline QDebug qWarning() { return QDebug(QtWarningMsg); }









# 1 "/usr/include/qt4/QtCore/QDebug" 2
# 33 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp" 2


namespace PySide
{




class __attribute__ ((visibility("default"))) qptr_base
{
public:
    enum construction_mode {
        none = 0x00000000,
        check_cache = 0x00000001,
        no_check_cache = 0x00000002,
        wrapper_pointer = 0x00000004,
        no_wrapper_pointer = 0x00000008
    };

    qptr_base(void* cpp_obj, PyObject *py_obj, void (*deleter)(void*), int mode);
    qptr_base(const qptr_base& other);
    qptr_base() : m_data(0) {}
    virtual ~qptr_base();






    static void invalidate(void *cpp_obj, bool cleanup = false);
    static bool exists(void *cpp_obj);

    bool is_null() const;

    qptr_base& operator=(const qptr_base& other);

    bool
    operator==(const qptr_base& other)
    {
        return m_data == other.m_data;
    }


    void acquire_ownership();
    void release_ownership();
    bool has_ownership();


    bool is_wrapper() const;
    void add_cpp_ref();
    void remove_cpp_ref();
    bool has_cpp_ref();

    void add_child(qptr_base &child);
    void remove_child(qptr_base &child);
    void remove_parent();

    PyObject* get_pyobject();
    void set_pyobject(PyObject *py_obj);

    void release();


    bool has_parent();
    int children_count();
    int refcount();
    static inline int list_size() { return m_cpp_to_qptrs.size(); }

    void* raw_ptr() const;

protected:
    bool ptr_assert() const;
    void destroy();
    void invalidate();
    void invalidate(bool invalidate_ptr);

    class qptr_base_private;
    mutable qptr_base_private* m_data;
    static QHash<const volatile void*, qptr_base_private*> m_cpp_to_qptrs;
    explicit qptr_base(qptr_base::qptr_base_private* data);
    qptr_base_private* create_copy() const;
};


template<typename T>
inline __attribute__ ((visibility("internal")))
void delete_pointer(T *p)
{
    delete p;
}

template<typename T>
inline __attribute__ ((visibility("internal")))
void delete_pointer_helper(void* p)
{
    T *ptr = reinterpret_cast<T*>(p);
    delete_pointer(ptr);
}




template<class T,
         int c_mode = (int) qptr_base::check_cache>
class __attribute__ ((visibility("internal"))) qptr : public qptr_base
{
public:
    typedef T element_type;
    typedef T value_type;
    typedef T * pointer;

public:
    qptr(T* ptr, int mode = c_mode)
        : qptr_base(get_void_pointer(ptr),
                    (mode & wrapper_pointer ? extract_pyobject(ptr, boost::is_polymorphic<T>()) : 0 ),
                    &delete_pointer_helper<T>, mode)
    {
    }

    template<typename Y>
    qptr(const qptr<Y>& ptr) : qptr_base(ptr)
    {
    }

    qptr(T* ptr, PyObject* py_obj)
        : qptr_base(get_void_pointer(ptr), py_obj, &delete_pointer_helper<T>, no_check_cache | no_wrapper_pointer)
    {
    }

    qptr(PyObject* py_obj)
        : qptr_base(get_void_pointer(boost::python::extract<T*>(py_obj)), py_obj,
                    &delete_pointer_helper<T>, c_mode)
    {
    }

    template<typename Y>
    qptr&
    operator=(const qptr<Y>& ptr)
    {
        if ( m_data != ptr.m_data ) {
            release();
            m_data = ptr.create_copy();
        }
        return *this;
    }

    inline T&
    operator*() const
    {
        return *get();
    }

    inline T*
    operator->() const
    {
        return get();
    }

    inline T*
    get() const
    {
        ptr_assert();
        return reinterpret_cast<T*>(raw_ptr());
    }

    ~qptr()
    {
        if (!is_null() && refcount() == 1 && has_cpp_ref()) {
            notify_ptr_del(reinterpret_cast<T*>(raw_ptr()), boost::is_polymorphic<T>());
        }
    }

    static inline void* get_void_pointer(T* pointer)
    {
        return get_void_pointer(pointer, boost::is_polymorphic<T>());
    }

private:
    static inline PyObject*
    extract_pyobject(T* ptr, boost::mpl::false_)
    {
        return 0;
    }

    static inline PyObject*
    extract_pyobject(T* ptr, boost::mpl::true_)
    {
        PySide::wrapper *w = dynamic_cast<PySide::wrapper*>(ptr);
        if (w)
            return w->py_object();
        else
            return 0;
    }

    static inline void
    notify_ptr_del(T* ptr, boost::mpl::false_)
    {
    }

    static inline void
    notify_ptr_del(T* ptr, boost::mpl::true_)
    {
        PySide::wrapper *w = dynamic_cast<PySide::wrapper*>(ptr);
        if (w)
            w->keep_cpp_ref();
    }

    static inline void*
    get_void_pointer(T* ptr, boost::mpl::false_)
    {
        return static_cast<void*>(ptr);
    }

    static inline void*
    get_void_pointer(T* ptr, boost::mpl::true_)
    {
        boost::python::objects::dynamic_id_t base_id =
            boost::python::objects::polymorphic_id_generator<T>::execute(ptr);
        return base_id.first;
    }

};




template<class T, int mode>
inline __attribute__ ((visibility("internal"))) T*
get_pointer(qptr<T, mode> const& p){
    return p.get();
}

}
# 32 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp" 2

namespace PySide
{







template <
    class T
    , class BasePolicy_ = boost::python::default_call_policies>
struct __attribute__ ((visibility("internal"))) register_wrapper_object : BasePolicy_
{
    template <class ArgumentPackage>
    static PyObject*
    postcall(ArgumentPackage const& args_, PyObject* result)
    {
        result = BasePolicy_::postcall(args_, result);
        if (result) {

            PyObject* py_self =
                    boost::python::detail::get_prev<1>::execute(args_, result);
            qptr<T> ptr_parent(py_self);
        }
        return result;
    }
};
# 72 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
template <
    std::size_t parent
  , std::size_t child
  , class T_PARENT
  , class T_CHILD
  , class BasePolicy_ = boost::python::default_call_policies
  , class T = void>
struct __attribute__ ((visibility("internal"))) parent_policy_add : BasePolicy_
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((parent != child) == 0 ? false : true) >)> boost_static_assert_typedef_81;

    template <class ArgumentPackage>
    static PyObject*
    postcall(ArgumentPackage const& args_, PyObject* result)
    {
        unsigned arity_ = boost::python::detail::arity(args_);
        if ((std::max)(parent, child) > arity_) {


            return BasePolicy_::postcall(args_, result);
        }

        result = BasePolicy_::postcall(args_, result);
        if (result) {
            PyObject* py_parent = (&_Py_NoneStruct);
            if (parent <= arity_)
                py_parent = boost::python::detail::get_prev<parent>::execute(args_, result);

            PyObject* py_child = boost::python::detail::get_prev<child>::execute(args_, result);
            if (py_child == (&_Py_NoneStruct)) {
                return result;
            } else if (py_parent == (&_Py_NoneStruct)) {
                qptr<T_CHILD> ptr_child(py_child);
                ptr_child.remove_parent();
            } else {
                qptr<T_PARENT> ptr_parent(py_parent);
                qptr<T_CHILD> ptr_child(py_child);

                if (ptr_parent.is_wrapper()) {
                    ptr_parent.add_child(ptr_child);
                } else {
                    ptr_child.add_cpp_ref();
                }
            }
        }
        return result;
    }

};

template < std::size_t parent
            , std::size_t child
            , class T_PARENT
            , class BasePolicy_
            , class T>
struct __attribute__ ((visibility("internal"))) parent_policy_add<parent, child, T_PARENT, QList<T*>, BasePolicy_ > : BasePolicy_
{
    template <class ArgumentPackage>
    static PyObject*
    postcall(ArgumentPackage const& args_, PyObject* result)
    {
        unsigned arity_ = boost::python::detail::arity(args_);
        if ((std::max)(parent, child) > arity_) {
            return BasePolicy_::postcall(args_, result);
        }

        result = BasePolicy_::postcall(args_, result);
        if (result) {
            PyObject* py_parent = (&_Py_NoneStruct);
            if (parent <= arity_)
                py_parent = boost::python::detail::get_prev<parent>::execute(args_, result);

            PyObject* py_child = boost::python::detail::get_prev<child>::execute(args_, result);
            if (py_child == (&_Py_NoneStruct) || !((((((PyObject*)(py_child))->ob_type))->tp_flags & ((1L<<25))) != 0)) {
                return result;
            } else if (py_parent == (&_Py_NoneStruct)) {
                Py_ssize_t max = PyList_Size(py_child);
                for (Py_ssize_t i = 0; i < max; ++i) {
                    qptr<T> ptr_child(PyList_GetItem(py_child, i));
                    ptr_child.remove_parent();
                }
            } else {
                Py_ssize_t max = PyList_Size(py_child);
                qptr<T_PARENT> ptr_parent(py_parent);
                for (Py_ssize_t i = 0; i < max; ++i) {
                    qptr<T> ptr_child(PyList_GetItem(py_child, i));

                    if (ptr_parent.is_wrapper()) {
                       ptr_parent.add_child(ptr_child);
                    } else {
                        ptr_child.add_cpp_ref();
                    }
                }
            }
        }
        return result;
    }
};
# 179 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
template <
    std::size_t arg_index
  , bool release_ownership
  , class T
  , class BasePolicy_ = boost::python::default_call_policies>
struct __attribute__ ((visibility("internal"))) transfer_ownership : BasePolicy_
{
    template <class ArgumentPackage>
    static PyObject*
    postcall(ArgumentPackage const& args_, PyObject* result)
    {
        unsigned arity_ = boost::python::detail::arity(args_);
        if (arg_index > arity_) {
            PyErr_SetString(PyExc_IndexError,
                            "PySide::transfer_ownership: argument index out of range");
            return 0;
        }

        result = BasePolicy_::postcall(args_, result);
        if (result) {
            PyObject* py_arg = boost::python::detail::get_prev<arg_index>::execute(args_, result);

            qptr<T> ptr_child(py_arg);
            if (release_ownership)
                ptr_child.release_ownership();
            else
                ptr_child.acquire_ownership();
        }

        return result;
    }
};
# 223 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
template <
    std::size_t parent
  , std::size_t child
  , class T_PARENT
  , class T_CHILD
  , class BasePolicy_ = boost::python::default_call_policies
  , class T = void>
struct __attribute__ ((visibility("internal"))) parent_policy_remove : BasePolicy_
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((parent != child) == 0 ? false : true) >)> boost_static_assert_typedef_232;

    template <class ArgumentPackage>
    static PyObject*
    postcall(ArgumentPackage const& args_, PyObject* result)
    {
        unsigned arity_ = boost::python::detail::arity(args_);
        if ((std::max)(parent, child) > arity_) {
            PyErr_SetString(PyExc_IndexError,
                            "PyQt::parent_policy_remove: argument index out of range");
            return 0;
        }

        result = BasePolicy_::postcall(args_, result);
        if (result) {
            PyObject* py_parent = 0;
            if (parent <= arity_)
                py_parent = boost::python::detail::get_prev<parent>::execute(args_, result);

            PyObject* py_child = boost::python::detail::get_prev<child>::execute(args_, result);

            qptr<T_PARENT> ptr_parent(py_parent);
            qptr<T_CHILD> ptr_child(py_child);

            if (ptr_parent.is_wrapper()) {
                ptr_child.remove_parent();
            } else {
                ptr_child.remove_cpp_ref();
            }
        }

        return result;
    }
};

template < std::size_t parent
            , std::size_t child
            , class T_PARENT
            , class BasePolicy_
            , class T>
struct __attribute__ ((visibility("internal"))) parent_policy_remove<parent, child, T_PARENT, QList<T*>, BasePolicy_> : BasePolicy_
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((parent != child) == 0 ? false : true) >)> boost_static_assert_typedef_274;

    template <class ArgumentPackage>
    static PyObject*
    postcall(ArgumentPackage const& args_, PyObject* result)
    {
        unsigned arity_ = boost::python::detail::arity(args_);
        if ((std::max)(parent, child) > arity_) {
            PyErr_SetString(PyExc_IndexError,
                            "PyQt::parent_policy_remove: argument index out of range");
                            return 0;
        }

        result = BasePolicy_::postcall(args_, result);
        if (result) {
            PyObject* py_parent = 0;
            if (parent <= arity_)
                py_parent = boost::python::detail::get_prev<parent>::execute(args_, result);

            PyObject* py_child = boost::python::detail::get_prev<child>::execute(args_, result);
            if (((((((PyObject*)(py_child))->ob_type))->tp_flags & ((1L<<25))) != 0)) {
                qptr<T_PARENT> ptr_parent(py_parent);
                uint max = PyList_Size(py_child);
                for (Py_ssize_t i = 0; i < max; ++i) {
                    qptr<T> ptr_child(PyList_GetItem(py_child, i));

                    if (ptr_parent.is_wrapper()) {
                        ptr_child.remove_parent();
                    } else {
                        ptr_child.remove_cpp_ref();
                    }
                }
            }
        }
        return result;
    }
};







template<bool cpp_ownership>
struct __attribute__ ((visibility("internal"))) make_ptr_reference_holder
{
    template <class T>
    static PyObject*
    execute(T* p)
    {
        if(p == 0)
        {
            return boost::python::incref((&_Py_NoneStruct));
        }


        qptr<T> ptr(const_cast<T*>(p));
        PyObject *ret = ptr.get_pyobject();
        if (ret)
            return boost::python::incref(ret);

        ptr.set_pyobject(execute_impl(p));


        if (cpp_ownership) {
            ptr.release_ownership();
        }

        return ptr.get_pyobject();
    }

    template <class T>
    static PyObject*
    execute_impl(T* p)
    {
        typedef qptr<T> smart_pointer;
        typedef boost::python::objects::pointer_holder<smart_pointer, T> holder_t;

        smart_pointer ptr(const_cast<T*>(p));
        PyObject *ret = boost::python::objects::make_ptr_instance<T, holder_t>::execute(ptr);
        ptr.set_pyobject(ret);
        return ret;
    }
};
# 369 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
template <bool cpp_ownership = false>
struct __attribute__ ((visibility("internal"))) return_ptr_object
{
    template <class T>
    struct apply
    {
        typedef typename boost::mpl::if_c<
            boost::is_pointer<T>::value
            , boost::python::to_python_indirect<T, make_ptr_reference_holder<cpp_ownership> >
            , boost::python::detail::reference_existing_object_requires_a_pointer_or_reference_return_type<T>
        >::type type;
    };
};

struct __attribute__ ((visibility("internal"))) reference_ptr_object
{
    template <class T>
    struct apply
    {
        static const bool ok = boost::is_pointer<T>::value || boost::is_reference<T>::value
                                                                                    ;

        typedef typename boost::mpl::if_c<
            ok
            , boost::python::to_python_indirect<T, make_ptr_reference_holder<false> >
            , boost::python::detail::reference_existing_object_requires_a_pointer_or_reference_return_type<T>
        >::type type;
    };
};
# 407 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
template < std::size_t parent_arg
          , std::size_t child_arg
          , class T_PARENT
          , class T_CHILD
          , class BasePolicy_ = boost::python::default_call_policies
          , class T = void >
struct __attribute__ ((visibility("internal"))) return_object
    : parent_policy_add<parent_arg, child_arg, T_PARENT, T_CHILD, BasePolicy_, T>
{
 private:
    static const bool legal = parent_arg > 0;
 public:
    typedef typename boost::mpl::if_c<
        legal
        , reference_ptr_object
        , boost::python::detail::return_internal_reference_owner_arg_must_be_greater_than_zero<parent_arg>
    >::type result_converter;
};

template < std::size_t parent_arg
         , std::size_t child_arg
         , class T_PARENT
         , class BasePolicy_
         , class T >
struct __attribute__ ((visibility("internal"))) return_object<parent_arg, child_arg, T_PARENT, QList<T>, BasePolicy_>
: parent_policy_add<parent_arg, child_arg, T_PARENT, QList<T>, BasePolicy_, T>
{
};




template<class T>
inline boost::python::handle<>
ptr(T* data, bool take_ownership = false)
{
    if (data == 0)
        return boost::python::handle<>(boost::python::incref((&_Py_NoneStruct)));

    PyObject *ret;

    if (take_ownership) {
        boost::python::to_python_indirect<T, make_ptr_reference_holder<false> >
                convert;
        ret = convert(data);
    } else {
        boost::python::to_python_indirect<T, make_ptr_reference_holder<true> >
                convert;
        ret = convert(data);
    }
    return boost::python::handle<>(ret);
}

}
# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qcontainer_indexing_suite.hpp" 1
# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qcontainer_indexing_suite.hpp"
namespace PySide
{


template <class Container, bool NoProxy, class DerivedPolicies>
class __attribute__ ((visibility("internal"))) qcontainer_indexing_suite;

template <class Container, bool NoProxy>
class __attribute__ ((visibility("internal"))) final_qcontainer_derived_policies
    : public qcontainer_indexing_suite<Container, NoProxy,
                    final_qcontainer_derived_policies<Container, NoProxy> >
{};

template <class Container,
          bool NoProxy = false,
          class DerivedPolicies = final_qcontainer_derived_policies<Container,
                                                                    NoProxy> >
class __attribute__ ((visibility("internal"))) qcontainer_indexing_suite
    : public boost::python::indexing_suite <Container,
                                            DerivedPolicies,
                                            NoProxy>
{
public:
    typedef typename Container::value_type data_type;
    typedef typename Container::value_type key_type;
    typedef typename Container::size_type index_type;
    typedef typename Container::size_type size_type;
    typedef typename Container::difference_type difference_type;

    static typename boost::mpl::if_<boost::is_class<data_type>,
                                    data_type&,
                                    data_type>::type
    get_item(Container& container, index_type i)
    {
        return container[i];
    }

    static boost::python::object
    get_slice(Container& container, index_type from, index_type to)
    {
        if (from > to)
            return boost::python::object(Container());

        return boost::python::object(container.mid(from, to-from));
    }

    static void
    set_item(Container& container, index_type i, data_type const& v)
    {
        container[i] = v;
    }

    static void
    set_slice(Container& container, index_type from,
              index_type to, data_type const& v)
    {
        if (from > to)
            return;

        container.erase(container.begin()+from, container.end()+to);
        container.insert(container.begin()+from, v);
    }

    template <class Iter>
    static void
    set_slice(Container& container, index_type from,
              index_type to, Iter first, Iter last)
    {
        if (from > to) {
            std::copy(first, last, container.begin()+from);
        } else {
            container.erase(container.begin()+from, container.end()+to);
            std::copy(first, last, container.begin()+from);
        }
    }

    static void
    delete_item(Container& container, index_type i)
    {
        container.erase(container.begin()+i);
    }

    static void
    delete_slice(Container& container, index_type from, index_type to)
    {
        if (from > to)
            return;

        container.erase(container.begin()+from, container.begin()+to);
    }

    static size_t
    size(Container& container)
    {
        return container.size();
    }

    static bool
    contains(Container& container, key_type const& key)
    {
        return std::find(container.begin(), container.end(), key)
               != container.end();
    }

    static index_type
    convert_index(Container& container, PyObject* i_)
    {
        boost::python::extract<long> i(i_);
        if (i.check()) {
            long index = i();
            if (index < 0)
                index += DerivedPolicies::size(container);

            if (index >= long(container.size()) || index < 0) {
                PyErr_SetString(PyExc_IndexError, "Index out of range");
                boost::python::throw_error_already_set();
            }
            return index;
        }

        PyErr_SetString(PyExc_TypeError, "Invalid index type");
        boost::python::throw_error_already_set();
        return index_type();
    }

    static index_type
    get_min_index(Container& )
    {
        return 0;
    }

    static index_type
    get_max_index(Container& container)
    {
        return container.size();
    }

    static bool
    compare_index(Container& , index_type a, index_type b)
    {
        return a < b;
    }

    static void
    append(Container& container, data_type const& v)
    {
        container.push_back(v);
    }
};

}
# 32 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2

# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/thread_support.hpp" 1
# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/thread_support.hpp"
# 1 "/usr/include/python2.6/pystate.h" 1
# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/thread_support.hpp" 2
# 1 "/usr/include/python2.6/ceval.h" 1
# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/thread_support.hpp" 2

# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
# 32 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/thread_support.hpp" 2

namespace PySide
{

class __attribute__ ((visibility("default"))) thread_support
{
private:
    static bool m_enabled;
    thread_support() {}

public:
    static void init();
    static void shutdown();
    static inline bool enabled();
};

class __attribute__ ((visibility("default"))) thread_locker
{
private:
    PyThreadState *m_thread_state;
    PyGILState_STATE m_gstate;

public:
    thread_locker();
    ~thread_locker();
};

class __attribute__ ((visibility("default"))) py_allow_threads
{
private:
    PyThreadState *_save;

public:
    py_allow_threads();
    ~py_allow_threads();
};

}
# 34 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 1
# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp"
# 1 "/usr/include/qt4/QtCore/QDebug" 1
# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
# 1 "/usr/include/qt4/QtCore/QHash" 1
# 32 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
# 1 "/usr/include/qt4/QtCore/QString" 1
# 1 "/usr/include/qt4/QtCore/qstring.h" 1
# 1 "/usr/include/qt4/QtCore/QString" 2
# 33 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
# 1 "/usr/include/qt4/QtCore/QGenericArgument" 1
# 1 "/usr/include/qt4/QtCore/qobjectdefs.h" 1
# 1 "/usr/include/qt4/QtCore/QGenericArgument" 2
# 34 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
# 1 "/usr/include/qt4/QtCore/QSet" 1
# 1 "/usr/include/qt4/QtCore/qset.h" 1
# 1 "/usr/include/qt4/QtCore/QSet" 2
# 35 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2



# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
# 39 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp" 1
# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp"
# 1 "/usr/include/qt4/QtCore/QString" 1
# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp" 2
# 1 "/usr/include/qt4/QtCore/QGenericArgument" 1
# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp" 2


# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
# 33 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp" 1
# 34 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp" 2

namespace PySide
{

class __attribute__ ((visibility("internal"))) type_details
{
    typedef boost::python::object(*func_cpp_to_python_type)(void*);
    typedef QGenericArgument(*func_python_to_cpp_type)(const boost::python::object&, const char*);
    typedef void(*func_delete_type)(void*);


    type_details() {}
    type_details(const type_details&);
    type_details& operator=(const type_details&);

public:
    template<typename T>
    static type_details*
    create_object_type_details(const char* type_name) {
        type_details* self = new type_details();
        self->m_type_name = type_name;
        self->m_type_object = boost::python::converter::registry::query(boost::python::type_id<T>())->get_class_object();
        self->m_func_cpp_to_python = &objecttype_to_python<T>;
        self->m_func_python_to_cpp = &python_to_objecttype<T*>;
        self->m_func_delete = 0;
        return self;
    }

    template<typename T>
    static type_details*
    create_value_type_details(const char* type_name) {
        type_details* self = new type_details();
        self->m_type_name = type_name;
        self->m_type_object = boost::python::converter::registry::query(boost::python::type_id<T>())->get_class_object();
        self->m_func_cpp_to_python = &valuetype_to_python<T>;
        self->m_func_python_to_cpp = &python_to_value_type<T>;
        self->m_func_delete = &func_delete_data<T>;
        return self;
    }
    template<typename T>
    static type_details*
    create_native_type_details(const char* type_name) {
        type_details* self = new type_details();
        self->m_type_name = type_name;
        self->m_type_object = 0;
        self->m_func_cpp_to_python = &native_to_python<T>;
        self->m_func_python_to_cpp = &python_to_value_type<T>;
        self->m_func_delete = &func_delete_data<T>;
        return self;
    }

    template<typename T>
    static type_details*
    create_container_type_details(const char* type_name) {
        type_details* self = new type_details();
        self->m_type_name = type_name;
        self->m_type_object = 0;
        self->m_func_cpp_to_python = &container_to_python<T>;
        self->m_func_python_to_cpp = &python_to_container<T>;
        self->m_func_delete = &func_delete_data<T>;
        return self;
    }

    boost::python::object
    to_python(void *data) const
    {
        return m_func_cpp_to_python(data);
    }

    QGenericArgument
    to_cpp(const boost::python::object &obj) const
    {
        return m_func_python_to_cpp(obj, m_type_name);
    }

    const PyTypeObject*
    get_python_type_object() const
    {
        return m_type_object;
    }

    void
    delete_data(QGenericArgument &arg) const
    {
        if (m_func_delete)
            m_func_delete(arg.data());
    }

private:
    const char* m_type_name;
    const PyTypeObject *m_type_object;

    func_cpp_to_python_type m_func_cpp_to_python;
    func_python_to_cpp_type m_func_python_to_cpp;
    func_delete_type m_func_delete;


    template <class T>
    static boost::python::object
    objecttype_to_python(void* p)
    {
        T* obj = *(reinterpret_cast< T*(*)>(p));
        boost::python::object py_obj(PySide::ptr(obj));
        if (!py_obj.ptr())
        {
            fprintf(stderr, "Fail to create python object from object in adress: %p\n", obj);
            py_obj = boost::python::object();
        }
        else
        {
            boost::python::incref(py_obj.ptr());
        }

        return py_obj;
    }

    template <class T>
    static QGenericArgument
    python_to_objecttype(const boost::python::object &obj, const char *type_name)
    {
        T val = boost::python::extract<T>(obj);
        return QGenericArgument(type_name, val);
    }


    template <class T>
    static boost::python::object
    valuetype_to_python(void* p)
    {
        T* val = reinterpret_cast<T*>(p);
        return boost::python::object(val);
    }

    template <class T>
    static QGenericArgument
    python_to_value_type(const boost::python::object& obj, const char *type_name)
    {
        T* val = new T(boost::python::extract<T>(obj));
        return QGenericArgument(type_name, static_cast<const void*>(val));
    }

    template <typename T>
    static QGenericArgument
    python_to_container(const boost::python::object& obj, const char* type_name)
    {
        T* val = new T(boost::python::extract<T>(obj));
        return QGenericArgument(type_name, static_cast<const void*>(val));
    }

    template <typename T>
    static boost::python::object
    container_to_python(void* p)
    {
        return boost::python::object(reinterpret_cast<T*>(p));
    }

    template<typename T>
    static boost::python::object
    container_value_to_python(T t)
    {
        return valuetype_to_python<T>(&t);
    }

    template<typename T>
    static boost::python::object
    container_value_to_python(T* t)
    {
        return objecttype_to_python<T>(&t);
    }

    template <class T>
    static void
    func_delete_data(void *data)
    {
        delete reinterpret_cast<T*>(data);
    }

    template<typename T>
    static boost::python::object
    native_to_python(void* p)
    {
        T* val = new T(*reinterpret_cast<T*>(p));
        return boost::python::object(*val);
    }
};

}
# 40 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2


namespace PySide
{

class __attribute__ ((visibility("default"))) type_manager
{
public:
    static type_manager& instance();
    ~type_manager();

    boost::python::object to_python(const QString &name, void *data);
    QGenericArgument to_cpp(const QString &name, const boost::python::object &obj);
    void delete_data(QGenericArgument &arg);

    template<typename T>
    void __attribute__ ((visibility("internal")))
    register_object_type(const char* type_name)
    {
        m_type_map[type_name] = type_details::create_object_type_details<T>(type_name);
    }

    template<typename T>
    void __attribute__ ((visibility("internal")))
    register_value_type(const char* type_name)
    {
        m_type_map[type_name] = type_details::create_value_type_details<T>(type_name);
    }

    template<typename T>
    void __attribute__ ((visibility("internal")))
    register_native_type(const char* type_name)
    {
        m_type_map[type_name] = type_details::create_native_type_details<T>(type_name);
    }

    template<typename T>
    void __attribute__ ((visibility("internal")))
    register_container_type(const char* type_name)
    {
        m_type_map[type_name] = type_details::create_container_type_details<T>(type_name);
    }


    bool __attribute__ ((visibility("internal")))
    register_converter(const char* type_name) {
        QString key(type_name);
         if (m_registered_converters.contains(key))
            return false;
         m_registered_converters << key;
         return true;
    }

    const type_details*
    get_type_details(const char* type_name)
    {
        return m_type_map[type_name];
    }


private:
    QSet<QString> m_registered_converters;
    QHash<QString, type_details* > m_type_map;
    type_manager();
    type_manager(const type_manager&);
};

}
# 35 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2

# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 1
# 27 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp"
# 1 "/usr/include/qt4/QtCore/QHash" 1
# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 2
# 1 "/usr/include/qt4/QtCore/QList" 1
# 1 "/usr/include/qt4/QtCore/qlist.h" 1
# 1 "/usr/include/qt4/QtCore/QList" 2
# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 2
# 1 "/usr/include/qt4/QtCore/QByteArray" 1
# 1 "/usr/include/qt4/QtCore/qbytearray.h" 1
# 1 "/usr/include/qt4/QtCore/QByteArray" 2
# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 2

# 1 "/usr/include/qt4/QtCore/QMap" 1
# 1 "/usr/include/qt4/QtCore/qmap.h" 1
# 1 "/usr/include/qt4/QtCore/QMap" 2
# 33 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 2

class QObject;

namespace PySide
{

class signal_holder;
class pyqt_signal;
class pyqt_slot;
class trigger;

struct signal_manager_data;
# 63 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp"
class __attribute__ ((visibility("default"))) signal_manager
{
public:

    static signal_manager& instance();


    bool connect(QObject* src, const pyqt_signal& signal,
                 boost::python::object& callable, Qt::ConnectionType type = Qt::AutoConnection);

    bool connect(QObject* sender, const pyqt_signal& signal,
                 QObject* receiver, const pyqt_slot& slot, Qt::ConnectionType type = Qt::AutoConnection);

    bool disconnect(QObject* src, const pyqt_signal& signal,
                    boost::python::object& callable);

    bool disconnect(QObject* sender, const pyqt_signal& signal,
                    QObject* receiver,
                    const pyqt_slot& slot);

    int dynamicsignal_receivers(const QObject *sender,
                                const pyqt_signal &signal,
                                int offset) const;
    QList<QByteArray> signals_of(const QObject* obj);
# 96 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp"
    void register_dynamic_signal(QObject *src, const pyqt_signal& signal,
                                 trigger* trigger, int slot_id);
# 107 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp"
    QObject* register_dynamic_signal(QObject *parent,
                                     QObject *sender,
                                     const pyqt_signal& signal,
                                     const pyqt_signal& receiver);
# 119 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp"
    QObject* register_dynamic_slot(QObject *parent,
                                     const boost::python::object &callback,
                                     QString &slot_name);


    const QMetaObject* get_dynamic_metaobject(QObject* obj);


    void unregister_qobj(QObject* obj);


    void emit_(QObject *src, const pyqt_signal& signal,
               const boost::python::object& args);

    ~signal_manager();

    void register_sender(QObject* sender);
    void unregister_sender();
    QObject* sender();

private:
    signal_manager_data *m_data;

    trigger* find_trigger(QObject* src);
    trigger* get_trigger(const QObject *src) const;
    void emit_dynamic_signal(QObject *source, const pyqt_signal& signal,
                             const boost::python::object& args);
    void emit_native_signal(QObject *source, int signal_index,
                            const pyqt_signal& signal,
                            const boost::python::object& args);
    void parse_objects_to_qarguments(const QStringList &args_type,
                                     const boost::python::object &argv,
                                     QList<QGenericArgument> &q_args);


    signal_manager();
    signal_manager(const signal_manager&);
    signal_manager& operator=(const signal_manager&);
};

class __attribute__ ((visibility("internal"))) set_sender
{
    signal_manager& m_sm;

public:
    set_sender(QObject* sender) : m_sm(signal_manager::instance())
    {
        m_sm.register_sender(sender);
    }

    ~set_sender()
    {
        m_sm.unregister_sender();
    }
};

}
# 37 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
# 35 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp" 2
# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.hpp" 1
# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.hpp"
using namespace PySide;

class __attribute__ ((visibility("internal"))) qwebpage_extensionoption_wrapper : public QWebPage::ExtensionOption, public PySide::wrapper
{

private:
    typedef boost::python::class_< QWebPage::ExtensionOption, PySide::qptr < qwebpage_extensionoption_wrapper, qptr_base::no_check_cache | qptr_base::wrapper_pointer> > class_type;
public:
    qwebpage_extensionoption_wrapper(PyObject *py_self, const QWebPage::ExtensionOption& self) : QWebPage::ExtensionOption(self), wrapper(py_self)
    {
    }
    qwebpage_extensionoption_wrapper(PyObject *py_self);
    ~qwebpage_extensionoption_wrapper();

    static void define_python_class() throw();

};
# 36 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp" 2




using namespace boost;
using namespace PySide;

qwebpage_extensionoption_wrapper::qwebpage_extensionoption_wrapper(PyObject *py_self)
 : QWebPage::ExtensionOption(), wrapper(py_self)
{
}

qwebpage_extensionoption_wrapper::~qwebpage_extensionoption_wrapper()
{
    PySide::qptr_base::invalidate(PySide::qptr<QWebPage::ExtensionOption >::get_void_pointer(this));
}
void qwebpage_extensionoption_wrapper::define_python_class() throw() {
    class_type python_cls("ExtensionOption", python::init< > ());

    python::scope qwebpage_extensionoption_wrapper_scope(python_cls);
    python::implicitly_convertible< PySide::qptr<qwebpage_extensionoption_wrapper>, PySide::qptr<QWebPage::ExtensionOption> >();
    python_cls.def(python::init<const QWebPage::ExtensionOption&>());
    type_manager::instance().register_value_type<QWebPage::ExtensionOption >("QWebPage::ExtensionOption");
}