--- /dev/null
+# 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 ®, 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 ®Exp);
+ QDataStream &operator>>(QDataStream &in, QRegExp ®Exp);
+
+
+
+
+
+# 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 ®ion);
+ 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 ®ion,
+ 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 ¢er, 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 ®ion);
+
+ 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 ¢er, 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 ©);
+ QUrl &operator =(const QUrl ©);
+
+ 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 ¢er, qreal radius, const QPointF &focalPoint);
+ QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qreal fy);
+
+ QRadialGradient(const QPointF ¢er, qreal radius);
+ QRadialGradient(qreal cx, qreal cy, qreal radius);
+
+ QPointF center() const;
+ void setCenter(const QPointF ¢er);
+ 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 ¢er, qreal startAngle);
+ QConicalGradient(qreal cx, qreal cy, qreal startAngle);
+
+ QPointF center() const;
+ void setCenter(const QPointF ¢er);
+ 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 ¶mNames, const QStringList ¶mValues);
+
+
+ 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*>(®istered<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 ¤t() 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 ¢er(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");
+}
git.wh0rd.org / ICEs.git / blobdiff